@hedystia/ws 2.3.3 → 2.3.5

package/dist/client.cjs

@@ -1,14 +1,24 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/client.ts
 /**
-* Resolve the best `WebSocket` constructor for the current runtime.
+* Resolve the `WebSocket` constructor from the current runtime's global scope.
 *
 * @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.
+* Every supported runtime exposes a WHATWG-compliant `WebSocket` natively:
 *
-* @returns A `WebSocket` constructor compatible with the WHATWG interface.
+* | Runtime       | Available since |
+* |---------------|-----------------|
+* | Browsers      | always          |
+* | Bun           | always          |
+* | Deno          | v1.4            |
+* | Node.js       | v22 (stable)    |
+*
+* If `globalThis.WebSocket` is not present (e.g. Node.js < 22 without a
+* polyfill), this function throws with a descriptive message instead of
+* silently falling back to a third-party package.
+*
+* @returns The global `WebSocket` constructor.
+* @throws {Error} When no native `WebSocket` is available in the current runtime.
 *
 * @example
 * ```ts
@@ -20,22 +30,23 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 */
 function resolveWebSocket() {
 	if (typeof globalThis !== "undefined" && globalThis.WebSocket) return globalThis.WebSocket;
-	const mod = require("ws");
-	return mod.WebSocket ?? mod;
+	throw new Error("@hedystia/ws: no native WebSocket found in globalThis. Ensure you are running Bun, Deno, a modern browser, or Node.js ≥ 22.");
 }
 /**
-* Create a `WebSocket` instance using the best available implementation
-* for the current runtime.
+* Create a `WebSocket` instance using the runtime's native `globalThis.WebSocket`.
 *
 * @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.
+* Custom request headers are only honoured on runtimes that expose them via
+* the second constructor argument (e.g. Bun).  On browsers and other
+* WHATWG-strict environments, `options.headers` is silently ignored —
+* matching standard WebSocket semantics.
 *
-* @param url - Absolute WebSocket URL (`ws://` or `wss://`)
-* @param options - Optional protocols / headers
+* @param url     - Absolute WebSocket URL (`ws://` or `wss://`).
+* @param options - Optional sub-protocols and headers, see {@link ClientWebSocketOptions}.
 * @returns A connected (or connecting) `WebSocket` instance.
 *
+* @throws {Error} When no native `WebSocket` is available in the current runtime.
+*
 * @example
 * ```ts
 * import { createWebSocket } from "@hedystia/ws/client";
@@ -45,32 +56,31 @@ function resolveWebSocket() {
 *   headers: { authorization: "Bearer ..." },
 * });
 *
-* ws.onopen = () => ws.send("hi");
+* ws.onopen    = () => ws.send("hi");
 * ws.onmessage = (event) => console.log(event.data);
 * ```
 */
 function createWebSocket(url, options) {
 	const Ctor = resolveWebSocket();
-	if (typeof globalThis !== "undefined" && globalThis.WebSocket === Ctor) return options?.protocols ? new Ctor(url, options.protocols) : new Ctor(url);
-	const init = {};
-	if (options?.headers) init.headers = options.headers;
-	return new Ctor(url, options?.protocols, init);
+	if (options?.protocols) return new Ctor(url, options.protocols);
+	return new Ctor(url);
 }
 /**
 * Lightweight runtime-agnostic wrapper that mirrors a small, predictable
-* subset of the WHATWG WebSocket interface.
+* 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.
+* property (`socket.onmessage = …`) without referencing the global
+* `WebSocket` type directly.  Delegates all operations to the native
+* `WebSocket` produced by {@link createWebSocket}.
 *
 * @example
 * ```ts
 * import { WebSocketClient } from "@hedystia/ws/client";
 *
 * const client = new WebSocketClient("ws://localhost:3000");
-* client.onopen = () => client.send("hello");
+* client.onopen    = () => client.send("hello");
 * client.onmessage = (event) => console.log(event.data);
 * ```
 */
@@ -84,8 +94,8 @@ var WebSocketClient = class {
 	/**
 	* 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}
+	* @param url     - Absolute WebSocket URL (`ws://` or `wss://`).
+	* @param options - Optional sub-protocols / headers; see {@link ClientWebSocketOptions}.
 	*/
 	constructor(url, options) {
 		this.socket = createWebSocket(url, options);
@@ -93,7 +103,7 @@ var WebSocketClient = class {
 	/**
 	* Current connection state, mirroring {@link WebSocket.readyState}.
 	*
-	* @returns `0` connecting, `1` open, `2` closing, `3` closed.
+	* @returns `0` connecting · `1` open · `2` closing · `3` closed.
 	*/
 	get readyState() {
 		return this.socket.readyState;
@@ -101,7 +111,7 @@ var WebSocketClient = class {
 	/**
 	* Send a payload to the server.
 	*
-	* @param data - WHATWG-compatible payload
+	* @param data - WHATWG-compatible payload.
 	*/
 	send(data) {
 		this.socket.send(data);
@@ -109,8 +119,8 @@ var WebSocketClient = class {
 	/**
 	* Close the underlying socket.
 	*
-	* @param code - Close code (defaults to 1000)
-	* @param reason - Optional human-readable reason
+	* @param code   - Close code (defaults to `1000`).
+	* @param reason - Optional human-readable reason phrase.
 	*/
 	close(code, reason) {
 		this.socket.close(code, reason);

package/dist/client.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"client.cjs","names":[],"sources":["../src/client.ts"],"sourcesContent":["import type { ClientWebSocketOptions } from \"./types\";\n\nexport type { ClientWebSocketOptions } from \"./types\";\n\n/**\n * Resolve the best `WebSocket` constructor for the current runtime.\n *\n * @remarks\n * - Bun, Deno, browsers and Node ≥ 22 expose `globalThis.WebSocket`.\n * - Older Node falls back to the [`ws`](https://github.com/websockets/ws)\n *   package, which mirrors the WHATWG `WebSocket` API.\n *\n * @returns A `WebSocket` constructor compatible with the WHATWG interface.\n *\n * @example\n * ```ts\n * import { resolveWebSocket } from \"@hedystia/ws/client\";\n *\n * const WS = resolveWebSocket();\n * const socket = new WS(\"ws://localhost:3000\");\n * ```\n */\nexport function resolveWebSocket(): typeof WebSocket {\n  if (typeof globalThis !== \"undefined\" && (globalThis as any).WebSocket) {\n    return (globalThis as any).WebSocket as typeof WebSocket;\n  }\n  const mod = require(\"ws\");\n  return (mod.WebSocket ?? mod) as typeof WebSocket;\n}\n\n/**\n * Create a `WebSocket` instance using the best available implementation\n * for the current runtime.\n *\n * @remarks\n * Custom request headers are honoured on Node via the `ws` package; on\n * runtimes that ship a WHATWG-compliant global `WebSocket` (Bun, Deno,\n * browsers, Node ≥ 22) headers are ignored — matching standard semantics.\n *\n * @param url - Absolute WebSocket URL (`ws://` or `wss://`)\n * @param options - Optional protocols / headers\n * @returns A connected (or connecting) `WebSocket` instance.\n *\n * @example\n * ```ts\n * import { createWebSocket } from \"@hedystia/ws/client\";\n *\n * const ws = createWebSocket(\"ws://localhost:3000\", {\n *   protocols: \"v1\",\n *   headers: { authorization: \"Bearer ...\" },\n * });\n *\n * ws.onopen = () => ws.send(\"hi\");\n * ws.onmessage = (event) => console.log(event.data);\n * ```\n */\nexport function createWebSocket(url: string, options?: ClientWebSocketOptions): WebSocket {\n  const Ctor = resolveWebSocket();\n  const isWhatwg =\n    typeof globalThis !== \"undefined\" && (globalThis as any).WebSocket === (Ctor as any);\n\n  if (isWhatwg) {\n    return options?.protocols ? new Ctor(url, options.protocols as any) : new Ctor(url);\n  }\n\n  const init: any = {};\n  if (options?.headers) {\n    init.headers = options.headers;\n  }\n  return new (Ctor as any)(url, options?.protocols, init);\n}\n\n/**\n * Lightweight runtime-agnostic wrapper that mirrors a small, predictable\n * subset of the WHATWG WebSocket interface.\n *\n * @remarks\n * Useful for higher-level code that wants to assign event handlers by\n * property (`socket.onmessage = ...`) without caring whether the underlying\n * implementation comes from `globalThis.WebSocket` or the `ws` package.\n *\n * @example\n * ```ts\n * import { WebSocketClient } from \"@hedystia/ws/client\";\n *\n * const client = new WebSocketClient(\"ws://localhost:3000\");\n * client.onopen = () => client.send(\"hello\");\n * client.onmessage = (event) => console.log(event.data);\n * ```\n */\nexport class WebSocketClient {\n  /**\n   * Underlying WebSocket instance produced by {@link createWebSocket}.\n   *\n   * @readonly\n   */\n  readonly socket: WebSocket;\n\n  /**\n   * Create a new client and immediately initiate the connection.\n   *\n   * @param url - Absolute WebSocket URL (`ws://` or `wss://`)\n   * @param options - Optional protocols / headers, see {@link ClientWebSocketOptions}\n   */\n  constructor(url: string, options?: ClientWebSocketOptions) {\n    this.socket = createWebSocket(url, options);\n  }\n\n  /**\n   * Current connection state, mirroring {@link WebSocket.readyState}.\n   *\n   * @returns `0` connecting, `1` open, `2` closing, `3` closed.\n   */\n  get readyState(): number {\n    return this.socket.readyState;\n  }\n\n  /**\n   * Send a payload to the server.\n   *\n   * @param data - WHATWG-compatible payload\n   */\n  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {\n    this.socket.send(data as any);\n  }\n\n  /**\n   * Close the underlying socket.\n   *\n   * @param code - Close code (defaults to 1000)\n   * @param reason - Optional human-readable reason\n   */\n  close(code?: number, reason?: string): void {\n    this.socket.close(code, reason);\n  }\n\n  /**\n   * Assign the open-event listener.\n   */\n  set onopen(cb: ((ev: Event) => void) | null) {\n    (this.socket as any).onopen = cb;\n  }\n  /**\n   * Assign the message-event listener.\n   */\n  set onmessage(cb: ((ev: MessageEvent) => void) | null) {\n    (this.socket as any).onmessage = cb;\n  }\n  /**\n   * Assign the close-event listener.\n   */\n  set onclose(cb: ((ev: CloseEvent) => void) | null) {\n    (this.socket as any).onclose = cb;\n  }\n  /**\n   * Assign the error-event listener.\n   */\n  set onerror(cb: ((ev: Event) => void) | null) {\n    (this.socket as any).onerror = cb;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,mBAAqC;CACnD,IAAI,OAAO,eAAe,eAAgB,WAAmB,WAC3D,OAAQ,WAAmB;CAE7B,MAAM,MAAM,QAAQ,KAAK;CACzB,OAAQ,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B3B,SAAgB,gBAAgB,KAAa,SAA6C;CACxF,MAAM,OAAO,kBAAkB;CAI/B,IAFE,OAAO,eAAe,eAAgB,WAAmB,cAAe,MAGxE,OAAO,SAAS,YAAY,IAAI,KAAK,KAAK,QAAQ,UAAiB,GAAG,IAAI,KAAK,IAAI;CAGrF,MAAM,OAAY,EAAE;CACpB,IAAI,SAAS,SACX,KAAK,UAAU,QAAQ;CAEzB,OAAO,IAAK,KAAa,KAAK,SAAS,WAAW,KAAK;;;;;;;;;;;;;;;;;;;;AAqBzD,IAAa,kBAAb,MAA6B;;;;;;CAM3B;;;;;;;CAQA,YAAY,KAAa,SAAkC;EACzD,KAAK,SAAS,gBAAgB,KAAK,QAAQ;;;;;;;CAQ7C,IAAI,aAAqB;EACvB,OAAO,KAAK,OAAO;;;;;;;CAQrB,KAAK,MAA+D;EAClE,KAAK,OAAO,KAAK,KAAY;;;;;;;;CAS/B,MAAM,MAAe,QAAuB;EAC1C,KAAK,OAAO,MAAM,MAAM,OAAO;;;;;CAMjC,IAAI,OAAO,IAAkC;EAC3C,KAAM,OAAe,SAAS;;;;;CAKhC,IAAI,UAAU,IAAyC;EACrD,KAAM,OAAe,YAAY;;;;;CAKnC,IAAI,QAAQ,IAAuC;EACjD,KAAM,OAAe,UAAU;;;;;CAKjC,IAAI,QAAQ,IAAkC;EAC5C,KAAM,OAAe,UAAU"}
+{"version":3,"file":"client.cjs","names":[],"sources":["../src/client.ts"],"sourcesContent":["import type { ClientWebSocketOptions } from \"./types\";\n\nexport type { ClientWebSocketOptions } from \"./types\";\n\n/**\n * Resolve the `WebSocket` constructor from the current runtime's global scope.\n *\n * @remarks\n * Every supported runtime exposes a WHATWG-compliant `WebSocket` natively:\n *\n * | Runtime       | Available since |\n * |---------------|-----------------|\n * | Browsers      | always          |\n * | Bun           | always          |\n * | Deno          | v1.4            |\n * | Node.js       | v22 (stable)    |\n *\n * If `globalThis.WebSocket` is not present (e.g. Node.js < 22 without a\n * polyfill), this function throws with a descriptive message instead of\n * silently falling back to a third-party package.\n *\n * @returns The global `WebSocket` constructor.\n * @throws {Error} When no native `WebSocket` is available in the current runtime.\n *\n * @example\n * ```ts\n * import { resolveWebSocket } from \"@hedystia/ws/client\";\n *\n * const WS = resolveWebSocket();\n * const socket = new WS(\"ws://localhost:3000\");\n * ```\n */\nexport function resolveWebSocket(): typeof WebSocket {\n  if (typeof globalThis !== \"undefined\" && (globalThis as any).WebSocket) {\n    return (globalThis as any).WebSocket as typeof WebSocket;\n  }\n  throw new Error(\n    \"@hedystia/ws: no native WebSocket found in globalThis. \" +\n      \"Ensure you are running Bun, Deno, a modern browser, or Node.js ≥ 22.\",\n  );\n}\n\n/**\n * Create a `WebSocket` instance using the runtime's native `globalThis.WebSocket`.\n *\n * @remarks\n * Custom request headers are only honoured on runtimes that expose them via\n * the second constructor argument (e.g. Bun).  On browsers and other\n * WHATWG-strict environments, `options.headers` is silently ignored —\n * matching standard WebSocket semantics.\n *\n * @param url     - Absolute WebSocket URL (`ws://` or `wss://`).\n * @param options - Optional sub-protocols and headers, see {@link ClientWebSocketOptions}.\n * @returns A connected (or connecting) `WebSocket` instance.\n *\n * @throws {Error} When no native `WebSocket` is available in the current runtime.\n *\n * @example\n * ```ts\n * import { createWebSocket } from \"@hedystia/ws/client\";\n *\n * const ws = createWebSocket(\"ws://localhost:3000\", {\n *   protocols: \"v1\",\n *   headers: { authorization: \"Bearer ...\" },\n * });\n *\n * ws.onopen    = () => ws.send(\"hi\");\n * ws.onmessage = (event) => console.log(event.data);\n * ```\n */\nexport function createWebSocket(url: string, options?: ClientWebSocketOptions): WebSocket {\n  const Ctor = resolveWebSocket();\n\n  if (options?.protocols) {\n    return new Ctor(url, options.protocols as any);\n  }\n  return new Ctor(url);\n}\n\n/**\n * Lightweight runtime-agnostic wrapper that mirrors a small, predictable\n * subset of the WHATWG `WebSocket` interface.\n *\n * @remarks\n * Useful for higher-level code that wants to assign event handlers by\n * property (`socket.onmessage = …`) without referencing the global\n * `WebSocket` type directly.  Delegates all operations to the native\n * `WebSocket` produced by {@link createWebSocket}.\n *\n * @example\n * ```ts\n * import { WebSocketClient } from \"@hedystia/ws/client\";\n *\n * const client = new WebSocketClient(\"ws://localhost:3000\");\n * client.onopen    = () => client.send(\"hello\");\n * client.onmessage = (event) => console.log(event.data);\n * ```\n */\nexport class WebSocketClient {\n  /**\n   * Underlying WebSocket instance produced by {@link createWebSocket}.\n   *\n   * @readonly\n   */\n  readonly socket: WebSocket;\n\n  /**\n   * Create a new client and immediately initiate the connection.\n   *\n   * @param url     - Absolute WebSocket URL (`ws://` or `wss://`).\n   * @param options - Optional sub-protocols / headers; see {@link ClientWebSocketOptions}.\n   */\n  constructor(url: string, options?: ClientWebSocketOptions) {\n    this.socket = createWebSocket(url, options);\n  }\n\n  /**\n   * Current connection state, mirroring {@link WebSocket.readyState}.\n   *\n   * @returns `0` connecting · `1` open · `2` closing · `3` closed.\n   */\n  get readyState(): number {\n    return this.socket.readyState;\n  }\n\n  /**\n   * Send a payload to the server.\n   *\n   * @param data - WHATWG-compatible payload.\n   */\n  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {\n    this.socket.send(data as any);\n  }\n\n  /**\n   * Close the underlying socket.\n   *\n   * @param code   - Close code (defaults to `1000`).\n   * @param reason - Optional human-readable reason phrase.\n   */\n  close(code?: number, reason?: string): void {\n    this.socket.close(code, reason);\n  }\n\n  /**\n   * Assign the open-event listener.\n   */\n  set onopen(cb: ((ev: Event) => void) | null) {\n    (this.socket as any).onopen = cb;\n  }\n\n  /**\n   * Assign the message-event listener.\n   */\n  set onmessage(cb: ((ev: MessageEvent) => void) | null) {\n    (this.socket as any).onmessage = cb;\n  }\n\n  /**\n   * Assign the close-event listener.\n   */\n  set onclose(cb: ((ev: CloseEvent) => void) | null) {\n    (this.socket as any).onclose = cb;\n  }\n\n  /**\n   * Assign the error-event listener.\n   */\n  set onerror(cb: ((ev: Event) => void) | null) {\n    (this.socket as any).onerror = cb;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,mBAAqC;CACnD,IAAI,OAAO,eAAe,eAAgB,WAAmB,WAC3D,OAAQ,WAAmB;CAE7B,MAAM,IAAI,MACR,8HAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BH,SAAgB,gBAAgB,KAAa,SAA6C;CACxF,MAAM,OAAO,kBAAkB;CAE/B,IAAI,SAAS,WACX,OAAO,IAAI,KAAK,KAAK,QAAQ,UAAiB;CAEhD,OAAO,IAAI,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;AAsBtB,IAAa,kBAAb,MAA6B;;;;;;CAM3B;;;;;;;CAQA,YAAY,KAAa,SAAkC;EACzD,KAAK,SAAS,gBAAgB,KAAK,QAAQ;;;;;;;CAQ7C,IAAI,aAAqB;EACvB,OAAO,KAAK,OAAO;;;;;;;CAQrB,KAAK,MAA+D;EAClE,KAAK,OAAO,KAAK,KAAY;;;;;;;;CAS/B,MAAM,MAAe,QAAuB;EAC1C,KAAK,OAAO,MAAM,MAAM,OAAO;;;;;CAMjC,IAAI,OAAO,IAAkC;EAC3C,KAAM,OAAe,SAAS;;;;;CAMhC,IAAI,UAAU,IAAyC;EACrD,KAAM,OAAe,YAAY;;;;;CAMnC,IAAI,QAAQ,IAAuC;EACjD,KAAM,OAAe,UAAU;;;;;CAMjC,IAAI,QAAQ,IAAkC;EAC5C,KAAM,OAAe,UAAU"}

package/dist/client.d.cts

@@ -2,14 +2,24 @@ import { ClientWebSocketOptions } from "./types.cjs";
 
 //#region src/client.d.ts
 /**
- * Resolve the best `WebSocket` constructor for the current runtime.
+ * Resolve the `WebSocket` constructor from the current runtime's global scope.
  *
  * @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.
+ * Every supported runtime exposes a WHATWG-compliant `WebSocket` natively:
  *
- * @returns A `WebSocket` constructor compatible with the WHATWG interface.
+ * | Runtime       | Available since |
+ * |---------------|-----------------|
+ * | Browsers      | always          |
+ * | Bun           | always          |
+ * | Deno          | v1.4            |
+ * | Node.js       | v22 (stable)    |
+ *
+ * If `globalThis.WebSocket` is not present (e.g. Node.js < 22 without a
+ * polyfill), this function throws with a descriptive message instead of
+ * silently falling back to a third-party package.
+ *
+ * @returns The global `WebSocket` constructor.
+ * @throws {Error} When no native `WebSocket` is available in the current runtime.
  *
  * @example
  * ```ts
@@ -21,18 +31,20 @@ import { ClientWebSocketOptions } from "./types.cjs";
  */
 declare function resolveWebSocket(): typeof WebSocket;
 /**
- * Create a `WebSocket` instance using the best available implementation
- * for the current runtime.
+ * Create a `WebSocket` instance using the runtime's native `globalThis.WebSocket`.
  *
  * @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.
+ * Custom request headers are only honoured on runtimes that expose them via
+ * the second constructor argument (e.g. Bun).  On browsers and other
+ * WHATWG-strict environments, `options.headers` is silently ignored —
+ * matching standard WebSocket semantics.
  *
- * @param url - Absolute WebSocket URL (`ws://` or `wss://`)
- * @param options - Optional protocols / headers
+ * @param url     - Absolute WebSocket URL (`ws://` or `wss://`).
+ * @param options - Optional sub-protocols and headers, see {@link ClientWebSocketOptions}.
  * @returns A connected (or connecting) `WebSocket` instance.
  *
+ * @throws {Error} When no native `WebSocket` is available in the current runtime.
+ *
  * @example
  * ```ts
  * import { createWebSocket } from "@hedystia/ws/client";
@@ -42,26 +54,27 @@ declare function resolveWebSocket(): typeof WebSocket;
  *   headers: { authorization: "Bearer ..." },
  * });
  *
- * ws.onopen = () => ws.send("hi");
+ * ws.onopen    = () => ws.send("hi");
  * ws.onmessage = (event) => console.log(event.data);
  * ```
  */
 declare function createWebSocket(url: string, options?: ClientWebSocketOptions): WebSocket;
 /**
  * Lightweight runtime-agnostic wrapper that mirrors a small, predictable
- * subset of the WHATWG WebSocket interface.
+ * 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.
+ * property (`socket.onmessage = …`) without referencing the global
+ * `WebSocket` type directly.  Delegates all operations to the native
+ * `WebSocket` produced by {@link createWebSocket}.
  *
  * @example
  * ```ts
  * import { WebSocketClient } from "@hedystia/ws/client";
  *
  * const client = new WebSocketClient("ws://localhost:3000");
- * client.onopen = () => client.send("hello");
+ * client.onopen    = () => client.send("hello");
  * client.onmessage = (event) => console.log(event.data);
  * ```
  */
@@ -75,27 +88,27 @@ declare class WebSocketClient {
   /**
    * 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}
+   * @param url     - Absolute WebSocket URL (`ws://` or `wss://`).
+   * @param options - Optional sub-protocols / headers; see {@link ClientWebSocketOptions}.
    */
   constructor(url: string, options?: ClientWebSocketOptions);
   /**
    * Current connection state, mirroring {@link WebSocket.readyState}.
    *
-   * @returns `0` connecting, `1` open, `2` closing, `3` closed.
+   * @returns `0` connecting · `1` open · `2` closing · `3` closed.
    */
   get readyState(): number;
   /**
    * Send a payload to the server.
    *
-   * @param data - WHATWG-compatible payload
+   * @param data - WHATWG-compatible payload.
    */
   send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
   /**
    * Close the underlying socket.
    *
-   * @param code - Close code (defaults to 1000)
-   * @param reason - Optional human-readable reason
+   * @param code   - Close code (defaults to `1000`).
+   * @param reason - Optional human-readable reason phrase.
    */
   close(code?: number, reason?: string): void;
   /**

package/dist/client.d.mts

@@ -2,14 +2,24 @@ import { ClientWebSocketOptions } from "./types.mjs";
 
 //#region src/client.d.ts
 /**
- * Resolve the best `WebSocket` constructor for the current runtime.
+ * Resolve the `WebSocket` constructor from the current runtime's global scope.
  *
  * @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.
+ * Every supported runtime exposes a WHATWG-compliant `WebSocket` natively:
  *
- * @returns A `WebSocket` constructor compatible with the WHATWG interface.
+ * | Runtime       | Available since |
+ * |---------------|-----------------|
+ * | Browsers      | always          |
+ * | Bun           | always          |
+ * | Deno          | v1.4            |
+ * | Node.js       | v22 (stable)    |
+ *
+ * If `globalThis.WebSocket` is not present (e.g. Node.js < 22 without a
+ * polyfill), this function throws with a descriptive message instead of
+ * silently falling back to a third-party package.
+ *
+ * @returns The global `WebSocket` constructor.
+ * @throws {Error} When no native `WebSocket` is available in the current runtime.
  *
  * @example
  * ```ts
@@ -21,18 +31,20 @@ import { ClientWebSocketOptions } from "./types.mjs";
  */
 declare function resolveWebSocket(): typeof WebSocket;
 /**
- * Create a `WebSocket` instance using the best available implementation
- * for the current runtime.
+ * Create a `WebSocket` instance using the runtime's native `globalThis.WebSocket`.
  *
  * @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.
+ * Custom request headers are only honoured on runtimes that expose them via
+ * the second constructor argument (e.g. Bun).  On browsers and other
+ * WHATWG-strict environments, `options.headers` is silently ignored —
+ * matching standard WebSocket semantics.
  *
- * @param url - Absolute WebSocket URL (`ws://` or `wss://`)
- * @param options - Optional protocols / headers
+ * @param url     - Absolute WebSocket URL (`ws://` or `wss://`).
+ * @param options - Optional sub-protocols and headers, see {@link ClientWebSocketOptions}.
  * @returns A connected (or connecting) `WebSocket` instance.
  *
+ * @throws {Error} When no native `WebSocket` is available in the current runtime.
+ *
  * @example
  * ```ts
  * import { createWebSocket } from "@hedystia/ws/client";
@@ -42,26 +54,27 @@ declare function resolveWebSocket(): typeof WebSocket;
  *   headers: { authorization: "Bearer ..." },
  * });
  *
- * ws.onopen = () => ws.send("hi");
+ * ws.onopen    = () => ws.send("hi");
  * ws.onmessage = (event) => console.log(event.data);
  * ```
  */
 declare function createWebSocket(url: string, options?: ClientWebSocketOptions): WebSocket;
 /**
  * Lightweight runtime-agnostic wrapper that mirrors a small, predictable
- * subset of the WHATWG WebSocket interface.
+ * 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.
+ * property (`socket.onmessage = …`) without referencing the global
+ * `WebSocket` type directly.  Delegates all operations to the native
+ * `WebSocket` produced by {@link createWebSocket}.
  *
  * @example
  * ```ts
  * import { WebSocketClient } from "@hedystia/ws/client";
  *
  * const client = new WebSocketClient("ws://localhost:3000");
- * client.onopen = () => client.send("hello");
+ * client.onopen    = () => client.send("hello");
  * client.onmessage = (event) => console.log(event.data);
  * ```
  */
@@ -75,27 +88,27 @@ declare class WebSocketClient {
   /**
    * 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}
+   * @param url     - Absolute WebSocket URL (`ws://` or `wss://`).
+   * @param options - Optional sub-protocols / headers; see {@link ClientWebSocketOptions}.
    */
   constructor(url: string, options?: ClientWebSocketOptions);
   /**
    * Current connection state, mirroring {@link WebSocket.readyState}.
    *
-   * @returns `0` connecting, `1` open, `2` closing, `3` closed.
+   * @returns `0` connecting · `1` open · `2` closing · `3` closed.
    */
   get readyState(): number;
   /**
    * Send a payload to the server.
    *
-   * @param data - WHATWG-compatible payload
+   * @param data - WHATWG-compatible payload.
    */
   send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
   /**
    * Close the underlying socket.
    *
-   * @param code - Close code (defaults to 1000)
-   * @param reason - Optional human-readable reason
+   * @param code   - Close code (defaults to `1000`).
+   * @param reason - Optional human-readable reason phrase.
    */
   close(code?: number, reason?: string): void;
   /**

package/dist/client.mjs

@@ -1,14 +1,23 @@
-import { __require } from "./_virtual/_rolldown/runtime.mjs";
 //#region src/client.ts
 /**
-* Resolve the best `WebSocket` constructor for the current runtime.
+* Resolve the `WebSocket` constructor from the current runtime's global scope.
 *
 * @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.
+* Every supported runtime exposes a WHATWG-compliant `WebSocket` natively:
 *
-* @returns A `WebSocket` constructor compatible with the WHATWG interface.
+* | Runtime       | Available since |
+* |---------------|-----------------|
+* | Browsers      | always          |
+* | Bun           | always          |
+* | Deno          | v1.4            |
+* | Node.js       | v22 (stable)    |
+*
+* If `globalThis.WebSocket` is not present (e.g. Node.js < 22 without a
+* polyfill), this function throws with a descriptive message instead of
+* silently falling back to a third-party package.
+*
+* @returns The global `WebSocket` constructor.
+* @throws {Error} When no native `WebSocket` is available in the current runtime.
 *
 * @example
 * ```ts
@@ -20,22 +29,23 @@ import { __require } from "./_virtual/_rolldown/runtime.mjs";
 */
 function resolveWebSocket() {
 	if (typeof globalThis !== "undefined" && globalThis.WebSocket) return globalThis.WebSocket;
-	const mod = __require("ws");
-	return mod.WebSocket ?? mod;
+	throw new Error("@hedystia/ws: no native WebSocket found in globalThis. Ensure you are running Bun, Deno, a modern browser, or Node.js ≥ 22.");
 }
 /**
-* Create a `WebSocket` instance using the best available implementation
-* for the current runtime.
+* Create a `WebSocket` instance using the runtime's native `globalThis.WebSocket`.
 *
 * @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.
+* Custom request headers are only honoured on runtimes that expose them via
+* the second constructor argument (e.g. Bun).  On browsers and other
+* WHATWG-strict environments, `options.headers` is silently ignored —
+* matching standard WebSocket semantics.
 *
-* @param url - Absolute WebSocket URL (`ws://` or `wss://`)
-* @param options - Optional protocols / headers
+* @param url     - Absolute WebSocket URL (`ws://` or `wss://`).
+* @param options - Optional sub-protocols and headers, see {@link ClientWebSocketOptions}.
 * @returns A connected (or connecting) `WebSocket` instance.
 *
+* @throws {Error} When no native `WebSocket` is available in the current runtime.
+*
 * @example
 * ```ts
 * import { createWebSocket } from "@hedystia/ws/client";
@@ -45,32 +55,31 @@ function resolveWebSocket() {
 *   headers: { authorization: "Bearer ..." },
 * });
 *
-* ws.onopen = () => ws.send("hi");
+* ws.onopen    = () => ws.send("hi");
 * ws.onmessage = (event) => console.log(event.data);
 * ```
 */
 function createWebSocket(url, options) {
 	const Ctor = resolveWebSocket();
-	if (typeof globalThis !== "undefined" && globalThis.WebSocket === Ctor) return options?.protocols ? new Ctor(url, options.protocols) : new Ctor(url);
-	const init = {};
-	if (options?.headers) init.headers = options.headers;
-	return new Ctor(url, options?.protocols, init);
+	if (options?.protocols) return new Ctor(url, options.protocols);
+	return new Ctor(url);
 }
 /**
 * Lightweight runtime-agnostic wrapper that mirrors a small, predictable
-* subset of the WHATWG WebSocket interface.
+* 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.
+* property (`socket.onmessage = …`) without referencing the global
+* `WebSocket` type directly.  Delegates all operations to the native
+* `WebSocket` produced by {@link createWebSocket}.
 *
 * @example
 * ```ts
 * import { WebSocketClient } from "@hedystia/ws/client";
 *
 * const client = new WebSocketClient("ws://localhost:3000");
-* client.onopen = () => client.send("hello");
+* client.onopen    = () => client.send("hello");
 * client.onmessage = (event) => console.log(event.data);
 * ```
 */
@@ -84,8 +93,8 @@ var WebSocketClient = class {
 	/**
 	* 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}
+	* @param url     - Absolute WebSocket URL (`ws://` or `wss://`).
+	* @param options - Optional sub-protocols / headers; see {@link ClientWebSocketOptions}.
 	*/
 	constructor(url, options) {
 		this.socket = createWebSocket(url, options);
@@ -93,7 +102,7 @@ var WebSocketClient = class {
 	/**
 	* Current connection state, mirroring {@link WebSocket.readyState}.
 	*
-	* @returns `0` connecting, `1` open, `2` closing, `3` closed.
+	* @returns `0` connecting · `1` open · `2` closing · `3` closed.
 	*/
 	get readyState() {
 		return this.socket.readyState;
@@ -101,7 +110,7 @@ var WebSocketClient = class {
 	/**
 	* Send a payload to the server.
 	*
-	* @param data - WHATWG-compatible payload
+	* @param data - WHATWG-compatible payload.
 	*/
 	send(data) {
 		this.socket.send(data);
@@ -109,8 +118,8 @@ var WebSocketClient = class {
 	/**
 	* Close the underlying socket.
 	*
-	* @param code - Close code (defaults to 1000)
-	* @param reason - Optional human-readable reason
+	* @param code   - Close code (defaults to `1000`).
+	* @param reason - Optional human-readable reason phrase.
 	*/
 	close(code, reason) {
 		this.socket.close(code, reason);

package/dist/client.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"client.mjs","names":[],"sources":["../src/client.ts"],"sourcesContent":["import type { ClientWebSocketOptions } from \"./types\";\n\nexport type { ClientWebSocketOptions } from \"./types\";\n\n/**\n * Resolve the best `WebSocket` constructor for the current runtime.\n *\n * @remarks\n * - Bun, Deno, browsers and Node ≥ 22 expose `globalThis.WebSocket`.\n * - Older Node falls back to the [`ws`](https://github.com/websockets/ws)\n *   package, which mirrors the WHATWG `WebSocket` API.\n *\n * @returns A `WebSocket` constructor compatible with the WHATWG interface.\n *\n * @example\n * ```ts\n * import { resolveWebSocket } from \"@hedystia/ws/client\";\n *\n * const WS = resolveWebSocket();\n * const socket = new WS(\"ws://localhost:3000\");\n * ```\n */\nexport function resolveWebSocket(): typeof WebSocket {\n  if (typeof globalThis !== \"undefined\" && (globalThis as any).WebSocket) {\n    return (globalThis as any).WebSocket as typeof WebSocket;\n  }\n  const mod = require(\"ws\");\n  return (mod.WebSocket ?? mod) as typeof WebSocket;\n}\n\n/**\n * Create a `WebSocket` instance using the best available implementation\n * for the current runtime.\n *\n * @remarks\n * Custom request headers are honoured on Node via the `ws` package; on\n * runtimes that ship a WHATWG-compliant global `WebSocket` (Bun, Deno,\n * browsers, Node ≥ 22) headers are ignored — matching standard semantics.\n *\n * @param url - Absolute WebSocket URL (`ws://` or `wss://`)\n * @param options - Optional protocols / headers\n * @returns A connected (or connecting) `WebSocket` instance.\n *\n * @example\n * ```ts\n * import { createWebSocket } from \"@hedystia/ws/client\";\n *\n * const ws = createWebSocket(\"ws://localhost:3000\", {\n *   protocols: \"v1\",\n *   headers: { authorization: \"Bearer ...\" },\n * });\n *\n * ws.onopen = () => ws.send(\"hi\");\n * ws.onmessage = (event) => console.log(event.data);\n * ```\n */\nexport function createWebSocket(url: string, options?: ClientWebSocketOptions): WebSocket {\n  const Ctor = resolveWebSocket();\n  const isWhatwg =\n    typeof globalThis !== \"undefined\" && (globalThis as any).WebSocket === (Ctor as any);\n\n  if (isWhatwg) {\n    return options?.protocols ? new Ctor(url, options.protocols as any) : new Ctor(url);\n  }\n\n  const init: any = {};\n  if (options?.headers) {\n    init.headers = options.headers;\n  }\n  return new (Ctor as any)(url, options?.protocols, init);\n}\n\n/**\n * Lightweight runtime-agnostic wrapper that mirrors a small, predictable\n * subset of the WHATWG WebSocket interface.\n *\n * @remarks\n * Useful for higher-level code that wants to assign event handlers by\n * property (`socket.onmessage = ...`) without caring whether the underlying\n * implementation comes from `globalThis.WebSocket` or the `ws` package.\n *\n * @example\n * ```ts\n * import { WebSocketClient } from \"@hedystia/ws/client\";\n *\n * const client = new WebSocketClient(\"ws://localhost:3000\");\n * client.onopen = () => client.send(\"hello\");\n * client.onmessage = (event) => console.log(event.data);\n * ```\n */\nexport class WebSocketClient {\n  /**\n   * Underlying WebSocket instance produced by {@link createWebSocket}.\n   *\n   * @readonly\n   */\n  readonly socket: WebSocket;\n\n  /**\n   * Create a new client and immediately initiate the connection.\n   *\n   * @param url - Absolute WebSocket URL (`ws://` or `wss://`)\n   * @param options - Optional protocols / headers, see {@link ClientWebSocketOptions}\n   */\n  constructor(url: string, options?: ClientWebSocketOptions) {\n    this.socket = createWebSocket(url, options);\n  }\n\n  /**\n   * Current connection state, mirroring {@link WebSocket.readyState}.\n   *\n   * @returns `0` connecting, `1` open, `2` closing, `3` closed.\n   */\n  get readyState(): number {\n    return this.socket.readyState;\n  }\n\n  /**\n   * Send a payload to the server.\n   *\n   * @param data - WHATWG-compatible payload\n   */\n  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {\n    this.socket.send(data as any);\n  }\n\n  /**\n   * Close the underlying socket.\n   *\n   * @param code - Close code (defaults to 1000)\n   * @param reason - Optional human-readable reason\n   */\n  close(code?: number, reason?: string): void {\n    this.socket.close(code, reason);\n  }\n\n  /**\n   * Assign the open-event listener.\n   */\n  set onopen(cb: ((ev: Event) => void) | null) {\n    (this.socket as any).onopen = cb;\n  }\n  /**\n   * Assign the message-event listener.\n   */\n  set onmessage(cb: ((ev: MessageEvent) => void) | null) {\n    (this.socket as any).onmessage = cb;\n  }\n  /**\n   * Assign the close-event listener.\n   */\n  set onclose(cb: ((ev: CloseEvent) => void) | null) {\n    (this.socket as any).onclose = cb;\n  }\n  /**\n   * Assign the error-event listener.\n   */\n  set onerror(cb: ((ev: Event) => void) | null) {\n    (this.socket as any).onerror = cb;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,mBAAqC;CACnD,IAAI,OAAO,eAAe,eAAgB,WAAmB,WAC3D,OAAQ,WAAmB;CAE7B,MAAM,MAAA,UAAc,KAAK;CACzB,OAAQ,IAAI,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B3B,SAAgB,gBAAgB,KAAa,SAA6C;CACxF,MAAM,OAAO,kBAAkB;CAI/B,IAFE,OAAO,eAAe,eAAgB,WAAmB,cAAe,MAGxE,OAAO,SAAS,YAAY,IAAI,KAAK,KAAK,QAAQ,UAAiB,GAAG,IAAI,KAAK,IAAI;CAGrF,MAAM,OAAY,EAAE;CACpB,IAAI,SAAS,SACX,KAAK,UAAU,QAAQ;CAEzB,OAAO,IAAK,KAAa,KAAK,SAAS,WAAW,KAAK;;;;;;;;;;;;;;;;;;;;AAqBzD,IAAa,kBAAb,MAA6B;;;;;;CAM3B;;;;;;;CAQA,YAAY,KAAa,SAAkC;EACzD,KAAK,SAAS,gBAAgB,KAAK,QAAQ;;;;;;;CAQ7C,IAAI,aAAqB;EACvB,OAAO,KAAK,OAAO;;;;;;;CAQrB,KAAK,MAA+D;EAClE,KAAK,OAAO,KAAK,KAAY;;;;;;;;CAS/B,MAAM,MAAe,QAAuB;EAC1C,KAAK,OAAO,MAAM,MAAM,OAAO;;;;;CAMjC,IAAI,OAAO,IAAkC;EAC3C,KAAM,OAAe,SAAS;;;;;CAKhC,IAAI,UAAU,IAAyC;EACrD,KAAM,OAAe,YAAY;;;;;CAKnC,IAAI,QAAQ,IAAuC;EACjD,KAAM,OAAe,UAAU;;;;;CAKjC,IAAI,QAAQ,IAAkC;EAC5C,KAAM,OAAe,UAAU"}
+{"version":3,"file":"client.mjs","names":[],"sources":["../src/client.ts"],"sourcesContent":["import type { ClientWebSocketOptions } from \"./types\";\n\nexport type { ClientWebSocketOptions } from \"./types\";\n\n/**\n * Resolve the `WebSocket` constructor from the current runtime's global scope.\n *\n * @remarks\n * Every supported runtime exposes a WHATWG-compliant `WebSocket` natively:\n *\n * | Runtime       | Available since |\n * |---------------|-----------------|\n * | Browsers      | always          |\n * | Bun           | always          |\n * | Deno          | v1.4            |\n * | Node.js       | v22 (stable)    |\n *\n * If `globalThis.WebSocket` is not present (e.g. Node.js < 22 without a\n * polyfill), this function throws with a descriptive message instead of\n * silently falling back to a third-party package.\n *\n * @returns The global `WebSocket` constructor.\n * @throws {Error} When no native `WebSocket` is available in the current runtime.\n *\n * @example\n * ```ts\n * import { resolveWebSocket } from \"@hedystia/ws/client\";\n *\n * const WS = resolveWebSocket();\n * const socket = new WS(\"ws://localhost:3000\");\n * ```\n */\nexport function resolveWebSocket(): typeof WebSocket {\n  if (typeof globalThis !== \"undefined\" && (globalThis as any).WebSocket) {\n    return (globalThis as any).WebSocket as typeof WebSocket;\n  }\n  throw new Error(\n    \"@hedystia/ws: no native WebSocket found in globalThis. \" +\n      \"Ensure you are running Bun, Deno, a modern browser, or Node.js ≥ 22.\",\n  );\n}\n\n/**\n * Create a `WebSocket` instance using the runtime's native `globalThis.WebSocket`.\n *\n * @remarks\n * Custom request headers are only honoured on runtimes that expose them via\n * the second constructor argument (e.g. Bun).  On browsers and other\n * WHATWG-strict environments, `options.headers` is silently ignored —\n * matching standard WebSocket semantics.\n *\n * @param url     - Absolute WebSocket URL (`ws://` or `wss://`).\n * @param options - Optional sub-protocols and headers, see {@link ClientWebSocketOptions}.\n * @returns A connected (or connecting) `WebSocket` instance.\n *\n * @throws {Error} When no native `WebSocket` is available in the current runtime.\n *\n * @example\n * ```ts\n * import { createWebSocket } from \"@hedystia/ws/client\";\n *\n * const ws = createWebSocket(\"ws://localhost:3000\", {\n *   protocols: \"v1\",\n *   headers: { authorization: \"Bearer ...\" },\n * });\n *\n * ws.onopen    = () => ws.send(\"hi\");\n * ws.onmessage = (event) => console.log(event.data);\n * ```\n */\nexport function createWebSocket(url: string, options?: ClientWebSocketOptions): WebSocket {\n  const Ctor = resolveWebSocket();\n\n  if (options?.protocols) {\n    return new Ctor(url, options.protocols as any);\n  }\n  return new Ctor(url);\n}\n\n/**\n * Lightweight runtime-agnostic wrapper that mirrors a small, predictable\n * subset of the WHATWG `WebSocket` interface.\n *\n * @remarks\n * Useful for higher-level code that wants to assign event handlers by\n * property (`socket.onmessage = …`) without referencing the global\n * `WebSocket` type directly.  Delegates all operations to the native\n * `WebSocket` produced by {@link createWebSocket}.\n *\n * @example\n * ```ts\n * import { WebSocketClient } from \"@hedystia/ws/client\";\n *\n * const client = new WebSocketClient(\"ws://localhost:3000\");\n * client.onopen    = () => client.send(\"hello\");\n * client.onmessage = (event) => console.log(event.data);\n * ```\n */\nexport class WebSocketClient {\n  /**\n   * Underlying WebSocket instance produced by {@link createWebSocket}.\n   *\n   * @readonly\n   */\n  readonly socket: WebSocket;\n\n  /**\n   * Create a new client and immediately initiate the connection.\n   *\n   * @param url     - Absolute WebSocket URL (`ws://` or `wss://`).\n   * @param options - Optional sub-protocols / headers; see {@link ClientWebSocketOptions}.\n   */\n  constructor(url: string, options?: ClientWebSocketOptions) {\n    this.socket = createWebSocket(url, options);\n  }\n\n  /**\n   * Current connection state, mirroring {@link WebSocket.readyState}.\n   *\n   * @returns `0` connecting · `1` open · `2` closing · `3` closed.\n   */\n  get readyState(): number {\n    return this.socket.readyState;\n  }\n\n  /**\n   * Send a payload to the server.\n   *\n   * @param data - WHATWG-compatible payload.\n   */\n  send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {\n    this.socket.send(data as any);\n  }\n\n  /**\n   * Close the underlying socket.\n   *\n   * @param code   - Close code (defaults to `1000`).\n   * @param reason - Optional human-readable reason phrase.\n   */\n  close(code?: number, reason?: string): void {\n    this.socket.close(code, reason);\n  }\n\n  /**\n   * Assign the open-event listener.\n   */\n  set onopen(cb: ((ev: Event) => void) | null) {\n    (this.socket as any).onopen = cb;\n  }\n\n  /**\n   * Assign the message-event listener.\n   */\n  set onmessage(cb: ((ev: MessageEvent) => void) | null) {\n    (this.socket as any).onmessage = cb;\n  }\n\n  /**\n   * Assign the close-event listener.\n   */\n  set onclose(cb: ((ev: CloseEvent) => void) | null) {\n    (this.socket as any).onclose = cb;\n  }\n\n  /**\n   * Assign the error-event listener.\n   */\n  set onerror(cb: ((ev: Event) => void) | null) {\n    (this.socket as any).onerror = cb;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,mBAAqC;CACnD,IAAI,OAAO,eAAe,eAAgB,WAAmB,WAC3D,OAAQ,WAAmB;CAE7B,MAAM,IAAI,MACR,8HAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BH,SAAgB,gBAAgB,KAAa,SAA6C;CACxF,MAAM,OAAO,kBAAkB;CAE/B,IAAI,SAAS,WACX,OAAO,IAAI,KAAK,KAAK,QAAQ,UAAiB;CAEhD,OAAO,IAAI,KAAK,IAAI;;;;;;;;;;;;;;;;;;;;;AAsBtB,IAAa,kBAAb,MAA6B;;;;;;CAM3B;;;;;;;CAQA,YAAY,KAAa,SAAkC;EACzD,KAAK,SAAS,gBAAgB,KAAK,QAAQ;;;;;;;CAQ7C,IAAI,aAAqB;EACvB,OAAO,KAAK,OAAO;;;;;;;CAQrB,KAAK,MAA+D;EAClE,KAAK,OAAO,KAAK,KAAY;;;;;;;;CAS/B,MAAM,MAAe,QAAuB;EAC1C,KAAK,OAAO,MAAM,MAAM,OAAO;;;;;CAMjC,IAAI,OAAO,IAAkC;EAC3C,KAAM,OAAe,SAAS;;;;;CAMhC,IAAI,UAAU,IAAyC;EACrD,KAAM,OAAe,YAAY;;;;;CAMnC,IAAI,QAAQ,IAAuC;EACjD,KAAM,OAAe,UAAU;;;;;CAMjC,IAAI,QAAQ,IAAkC;EAC5C,KAAM,OAAe,UAAU"}

package/dist/index.cjs

@@ -18,5 +18,6 @@ exports.isBun = require_runtime.isBun;
 exports.isDeno = require_runtime.isDeno;
 exports.isNode = require_runtime.isNode;
 exports.resolveWebSocket = require_client.resolveWebSocket;
+exports.serve = require_server.serve;
 
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["WebSocketServer"],"sources":["../src/index.ts"],"sourcesContent":["export type { ClientWebSocketOptions } from \"./client\";\nexport { createWebSocket, resolveWebSocket, WebSocketClient } from \"./client\";\nexport type { Runtime } from \"./runtime\";\nexport { detectRuntime, isBrowser, isBun, isDeno, isNode } from \"./runtime\";\nexport type {\n  ServerWebSocket,\n  UpgradeOptions,\n  UpgradeRequest,\n  WebSocketHandlers,\n  WebSocketServerOptions,\n  WSData,\n  WSMessage,\n} from \"./server\";\n\nimport { WebSocketServer } from \"./server\";\n\nexport { WebSocketServer };\n\nexport default WebSocketServer;\n"],"mappings":";;;;;;;;AAkBA,IAAA,cAAeA,eAAAA"}
+{"version":3,"file":"index.cjs","names":["WebSocketServer"],"sources":["../src/index.ts"],"sourcesContent":["export type { ClientWebSocketOptions } from \"./client\";\nexport { createWebSocket, resolveWebSocket, WebSocketClient } from \"./client\";\nexport type { Runtime } from \"./runtime\";\nexport { detectRuntime, isBrowser, isBun, isDeno, isNode } from \"./runtime\";\nexport type {\n  ServeInfo,\n  ServerWebSocket,\n  UpgradeOptions,\n  UpgradeRequest,\n  WebSocketHandlers,\n  WebSocketServerOptions,\n  WSData,\n  WSMessage,\n} from \"./server\";\n\nimport { serve, WebSocketServer } from \"./server\";\n\nexport { serve, WebSocketServer };\n\nexport default WebSocketServer;\n"],"mappings":";;;;;;;;AAmBA,IAAA,cAAeA,eAAAA"}

package/dist/index.d.cts

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