crossws 0.0.1 → 0.1.0

package/README.md

@@ -7,17 +7,20 @@
 
 <!-- [![Codecov][codecov-src]][codecov-href] -->
 
-> [!WARNING]
-> This project and API are under heavy development and trial. Please don't rely on it for production yet. Feedback is more than welcome!
+👉 Elegant, typed, and simple interface to implement platform-agnostic WebSocket servers
+
+🧩 Seamlessly integrates with, [Node.js](https://nodejs.org/en), [Bun](https://bun.sh/), [Deno](https://deno.com/) and [Cloudflare Workers](https://workers.cloudflare.com/)!
+
+🚀 High-performance server hooks, avoiding heavy per-connection events API ([why](https://bun.sh/docs/api/websockets#lcYFjkFYJC-summary))
 
-Cross-platform WebSocket Servers:
+📦 No external dependencies, includes [ws](https://github.com/websockets/ws) for Node.js support
 
-- Elegant, typed, and simple interface to define your WebSocket server handlers
-- Performant per-server handlers instead of per-connection events API ([why](https://bun.sh/docs/api/websockets#lcYFjkFYJC-summary))
-- Zero dependencies with bundled [ws](https://github.com/websockets/ws) types and runtime for [Node.js](https://nodejs.org/) support
-- Native integration with [Bun](https://bun.sh/) and [Deno](https://deno.com/) WebSocket API
-- Super lightweight tree-shakable packaging
-- Developer-Friendly logging
+💡 Extremely lightweight and tree-shakable packaging with ESM and CJS support
+
+🔍 Developer-friendly object logging
+
+> [!WARNING]
+> This project and API are under development.
 
 ## Install
 
@@ -35,9 +38,91 @@ pnpm install crossws
 bun install crossws
 ```
 
-## Integration
+## Unified Hooks
+
+CrossWS provides a cross-platform API to define WebSocket servers. An implementation with these hooks works across runtimes without needing you to go into details of any of them (while you always have the power to control low-level hooks). You can only define the life-cycle hooks that you only need and only those will be called run runtime.
+
+> [!NOTE]
+> For type support and IDE auto-completion, you can use `defineWebSocketHooks` utility or `WebSocketHooks` type export from the main.
+
+```ts
+import { defineWebSocketHooks } from "crossws";
+
+const websocketHooks = defineWebSocketHooks({
+  open(peer) {
+    console.log("[ws] open", peer);
+  },
+
+  message(peer, message) {
+    console.log("[ws] message", peer, message);
+    if (message.text().includes("ping")) {
+      peer.send("pong");
+    }
+  },
+
+  close(peer, event) {
+    console.log("[ws] close", peer, event);
+  },
+
+  error(peer, error) {
+    console.log("[ws] error", peer, error);
+  },
+
+  // ... platform hooks such as bun:drain ...
+});
+```
+
+### Peer Object
+
+Websocket hooks always accept a peer instance as the first argument. `peer`, keeps the state of the connected client.
+
+**Properties:**
+
+- `peer.id?`: The peer address or unique id (might be `undefined`)
+- `peer.readyState`: The connection status ([MDN](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/readyState))
+- `peer.ctx[name]`: Keeps the state of native client connection
+
+**Methods:**
+
+- `send(message, compress)`: Send a message to the connected client
+
+> [!TIP]
+> You can safely log a peer instance to the console using `console.log` it will be automatically stringified with useful information including the remote address and connection status!
+
+### Message Object
+
+on `message` hook, you receive a message object containing an incoming message from the client.
+
+**Properties:**
+
+- `message.rawData`: Raw message data
+- `message.isBinary`: Indicates if the message is binary (might be `undefined`)
+
+**Methods:**
+
+- `message.text()`: Get stringified version of the message
+
+> [!TIP]
+> You can safely log `message` object to the console using `console.log` it will be automatically stringified!
+
+## Error handling
+
+You can catch errors using `error` hook. The second argument is error wrapped into a `WebSocketError` class.
+
+## Universal WebSocket client
+
+CrossWS also exposes a universal way to use [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket) API in order to connect to the server. For all runtimes, except Node.js, native implementation is used, and for Node.js, a bundled version of [`ws.WebSocket`](https://www.npmjs.com/package/ws) is bundled.
+
+```js
+import WebSocket from "crossws/websocket";
+```
+
+> [!NOTE]
+> Using export conditions, the correct version will be always used so you don't have to worry about picking the right build!
+
+## Integrations
 
-CrossWS allows integrating your WebSocket handlers with different runtimes and platforms using built-in adapters. Each runtime has a specific method of integrating WebSocket. Once integrated, your custom handlers (such as `onMessage`) will work consistently even if you change the runtime!
+CrossWS allows integrating your WebSocket hooks with different runtimes and platforms using built-in adapters. Each runtime has a specific method of integrating WebSocket. Once integrated, your custom hooks (such as `message` and `close`) will work consistently even if you change the runtime!
 
 ### Integration with **Node.js**
 
@@ -53,26 +138,38 @@ const server = createServer((req, res) => {
   );
 }).listen(3000);
 
-// Initialize WebSocket Handler
+// Initialize WebSocket Hooks
 import nodeWSAdapter from "crossws/adapters/node";
 
-const { handleUpgrade } = nodeWSAdapter({ onMessage: console.log });
+const { handleUpgrade } = nodeWSAdapter({ message: console.log });
 server.on("upgrade", handleUpgrade);
 ```
 
+**Node-specific hooks:**
+
+- `node:open (peer)`
+- `node:message (peer, data, isBinary)`
+- `node:close (peer, code, reason)`
+- `node:error (peer, error)`
+- `node:ping (peer)`
+- `node:pong (peer)`
+- `node:unexpected-response (peer, req, res)`
+- `node:upgrade (peer, req)`
+
 See [playground/node.ts](./playground/node.ts) for demo and [src/adapters/node.ts](./src/adapters/node.ts) for implementation.
 
-## Integration with **Bun**
+### Integration with **Bun**
 
-To integrate crosws with your Bun server, you need to check for `server.upgrade` and also pass the `websocket` object returned from the adapter to server options. CrossWS leverages native Bun WebSocket API.
+To integrate CrossWS with your Bun server, you need to check for `server.upgrade` and also pass the `websocket` object returned from the adapter to server options. CrossWS leverages native Bun WebSocket API.
 
 ```ts
 import bunAdapter from "./dist/adapters/bun";
 
-const { websocket } = bunAdapter({ onMessage: console.log });
+const { websocket } = bunAdapter({ message: console.log });
 
 Bun.serve({
   port: 3000,
+  websocket,
   fetch(req, server) {
     if (server.upgrade(req)) {
       return;
@@ -82,20 +179,29 @@ Bun.serve({
       { headers: { "content-type": "text/html" } },
     );
   },
-  websocket,
 });
 ```
 
+**Bun-specific hooks:**
+
+- `bun:message (peer, ws,message)`
+- `bun:open (peer, ws)`
+- `bun:close (peer, ws)`
+- `bun:drain (peer)`
+- `bun:error (peer, ws, error)`
+- `bun:ping (peer, ws, data)`
+- `bun:pong (peer, ws, data)`
+
 See [playground/bun.ts](./playground/bun.ts) for demo and [src/adapters/bun.ts](./src/adapters/bun.ts) for implementation.
 
-## Integration with **Deno**
+### Integration with **Deno**
 
 To integrate CrossWS with your Deno server, you need to check for the `upgrade` header and then call `handleUpgrade` method from the adapter passing the incoming request object. The returned value is the server upgrade response.
 
 ```ts
 import denoAdapter from "crossws/adapters/deno";
 
-const { handleUpgrade } = denoAdapter({ onMessage: console.log });
+const { handleUpgrade } = denoAdapter({ message: console.log });
 
 Deno.serve({ port: 3000 }, (req) => {
   if (req.headers.get("upgrade") === "websocket") {
@@ -108,63 +214,56 @@ Deno.serve({ port: 3000 }, (req) => {
 });
 ```
 
-See [playground/deno.ts](./playground/deno.ts) for demo and [src/adapters/deno.ts](./src/adapters/deno.ts) for implementation.
+**Deno-specific hooks:**
 
-## Integration with other runtimes
+- `deno:open (peer)`
+- `deno:message (peer, event)`
+- `deno:close (peer)`
+- `deno:error (peer, error)`
 
-You can define your custom adapters using `defineWebSocketAdapter` wrapper.
-
-See other adapter implementations in [./src/adapters](./src/adapters/) to get and idea how adapters can be implemented and feel free to directly make a Pull Request to support your environment in CrossWS!
-
-## Handler API
-
-Previously you saw in the adapter examples that we pass `onMessage` option.
+See [playground/deno.ts](./playground/deno.ts) for demo and [src/adapters/deno.ts](./src/adapters/deno.ts) for implementation.
 
-First object passed to adapters is a list of global handlers that will get called during lifecycle of a WebSocket connection. You can use `defineWebSocketHandler` utility to make a typed websocket handler object and pass it to the actual adapter when needed.
+### Integration with **Cloudflare Workers**
 
-**Note: API is subject to change! Feedbacks Welcome!**
+To integrate CrossWS with your Cloudflare Workers, you need to check for the `upgrade` header
 
 ```ts
-import { defineWebSocketHandler } from "crossws";
+import cloudflareAdapter from "crossws/adapters/cloudflare";
 
-const websocketHandler = defineWebSocketHandler({
-  onMessage: (peer, message) => {
-    console.log("message", peer, message);
-    if (message.text().includes("ping")) {
-      peer.send("pong");
+const { handleUpgrade } = cloudflareAdapter({ message: console.log });
+
+export default {
+  async fetch(request, env, context) {
+    if (request.headers.get("upgrade") === "websocket") {
+      return handleUpgrade(request, env, context);
     }
+    return new Response(
+      `<script>new WebSocket("ws://localhost:3000").addEventListener("open", (e) => e.target.send("Hello from client!"));</script>`,
+      { headers: { "content-type": "text/html" } },
+    );
   },
-  onError: (peer, error) => {
-    console.log("error", peer, error);
-  },
-  onOpen: (peer) => {
-    console.log("open", peer);
-  },
-  onClose: (peer, code, reason) => {
-    console.log("close", peer, code, reason);
-  },
-  onEvent: (event, ...args) => {
-    console.log("event", event);
-  },
-});
+};
 ```
 
-### `WebSocketPeer`
+**Cloudflare-specific hooks:**
 
-Websocket handler methods accept a peer instance as first argument. peer is a wrapper over platform natives WebSocket connection instance and alows to send message.
+- `cloudflare:accept(peer)`
+- `cloudflare:message(peer, event)`
+- `cloudflare:error(peer, event)`
+- `cloudflare:close(peer, event)`
 
-**Tip:** You can safely log a peer instance to console using `console.log` it will be automatically stringified with useful information including remote address and connection status!
+See [playground/cloudflare.ts](./playground/cloudflare.ts) for demo and [src/adapters/cloudflare.ts](./src/adapters/cloudflare.ts) for implementation.
 
-### `WebSocketMessage`
+### Integration with other runtimes
 
-Second argument to `onMessage` event handler is a message object. You can access raw data using `message.rawData` or stringified message using `message.text()`.
+You can define your custom adapters using `defineWebSocketAdapter` wrapper.
 
-**Tip:** You can safely log `message` object to console using `console.log` it will be automatically stringified!
+See other adapter implementations in [./src/adapters](./src/adapters/) to get an idea of how adapters can be implemented and feel free to directly make a Pull Request to support your environment in CrossWS!
 
 ## Development
 
 - Clone this repository
-- Install latest LTS version of [Node.js](https://nodejs.org/en/)
+- Install the latest LTS version of [Node.js](https://nodejs.org/en/)
 - Enable [Corepack](https://github.com/nodejs/corepack) using `corepack enable`
 - Install dependencies using `pnpm install`
 - Run interactive tests using `pnpm dev`

package/adapters/bun.d.ts

@@ -0,0 +1 @@
+export * from "../dist/adapters/bun";

package/adapters/cloudflare.d.ts

@@ -0,0 +1 @@
+export * from "../dist/adapters/cloudflare";

package/adapters/deno.d.ts

@@ -0,0 +1 @@
+export * from "../dist/adapters/deno";

package/adapters/node.d.ts

@@ -0,0 +1 @@
+export * from "../dist/adapters/node";

package/dist/adapters/bun.cjs

@@ -1,57 +1,72 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
+const peer = require('../shared/crossws.21e14e0d.cjs');
 
-const peer = require('../shared/crossws.002417e5.cjs');
-
-const WebSocket = globalThis.WebSocket;
 const bun = peer.defineWebSocketAdapter(
-  (handler, opts = {}) => {
+  (hooks, opts = {}) => {
+    const getPeer = (ws) => {
+      if (ws.data?._peer) {
+        return ws.data._peer;
+      }
+      const peer = new WebSocketPeer({ bun: { ws } });
+      ws.data = ws.data || {};
+      ws.data._peer = peer;
+      return peer;
+    };
     return {
       websocket: {
         message: (ws, message) => {
-          handler.onEvent?.("bun:message", ws, message);
-          const peer$1 = new BunWebSocketPeer(ws);
-          handler.onMessage?.(peer$1, new peer.WebSocketMessage(message));
+          const peer$1 = getPeer(ws);
+          hooks["bun:message"]?.(peer$1, ws, message);
+          hooks.message?.(peer$1, new peer.WebSocketMessage(message));
         },
         open: (ws) => {
-          handler.onEvent?.("bun:open", ws);
-          const peer = new BunWebSocketPeer(ws);
-          handler.onOpen?.(peer);
+          const peer = getPeer(ws);
+          hooks["bun:open"]?.(peer, ws);
+          hooks.open?.(peer);
         },
         close: (ws) => {
-          handler.onEvent?.("bun:close", ws);
-          const peer = new BunWebSocketPeer(ws);
-          handler.onClose?.(peer, 0, "");
+          const peer = getPeer(ws);
+          hooks["bun:close"]?.(peer, ws);
+          hooks.close?.(peer, {});
+        },
+        drain: (ws) => {
+          const peer = getPeer(ws);
+          hooks["bun:drain"]?.(peer);
         },
+        // @ts-expect-error types unavailable but mentioned in docs
         error: (ws, error) => {
-          handler.onEvent?.("bun:error", ws, error);
-          const peer$1 = new BunWebSocketPeer(ws);
-          handler.onError?.(peer$1, new peer.WebSocketError(error));
+          const peer$1 = getPeer(ws);
+          hooks["bun:error"]?.(peer$1, ws, error);
+          hooks.error?.(peer$1, new peer.WebSocketError(error));
         },
-        drain: (ws) => {
-          handler.onEvent?.("bun:drain", ws);
+        ping(ws, data) {
+          const peer = getPeer(ws);
+          hooks["bun:ping"]?.(peer, ws, data);
+        },
+        pong(ws, data) {
+          const peer = getPeer(ws);
+          hooks["bun:pong"]?.(peer, ws, data);
         }
       }
     };
   }
 );
-class BunWebSocketPeer extends peer.WebSocketPeer {
-  constructor(_ws) {
-    super();
-    this._ws = _ws;
-  }
+class WebSocketPeer extends peer.WebSocketPeerBase {
   get id() {
-    return this._ws.remoteAddress;
+    let addr = this.ctx.bun.ws.remoteAddress;
+    if (addr.includes(":")) {
+      addr = `[${addr}]`;
+    }
+    return addr;
   }
   get readyState() {
-    return this._ws.readyState;
+    return this.ctx.bun.ws.readyState;
   }
   send(message) {
-    this._ws.send(message);
+    this.ctx.bun.ws.send(message);
     return 0;
   }
 }
 
-exports.WebSocket = WebSocket;
-exports.default = bun;
+module.exports = bun;

package/dist/adapters/bun.d.cts

@@ -1,43 +1,13 @@
 import { WebSocketAdapter } from '../index.cjs';
 
-interface BunWSOptions {
-    message: (ws: BunServerWebSocket, message: string | ArrayBuffer | Uint8Array) => void;
-    open?: (ws: BunServerWebSocket) => void;
-    close?: (ws: BunServerWebSocket) => void;
-    error?: (ws: BunServerWebSocket, error: Error) => void;
-    drain?: (ws: BunServerWebSocket) => void;
-    perMessageDeflate?: boolean | {
-        compress?: boolean | BunWSCompressor;
-        decompress?: boolean | BunWSCompressor;
-    };
-}
-type BunWSCompressor = `"disable"` | `"shared"` | `"dedicated"` | `"3KB"` | `"4KB"` | `"8KB"` | `"16KB"` | `"32KB"` | `"64KB"` | `"128KB"` | `"256KB"`;
-interface BunServerWebSocket {
-    readonly data: any;
-    readonly readyState: number;
-    readonly remoteAddress: string;
-    send(message: string | ArrayBuffer | Uint8Array, compress?: boolean): number;
-    close(code?: number, reason?: string): void;
-    subscribe(topic: string): void;
-    unsubscribe(topic: string): void;
-    publish(topic: string, message: string | ArrayBuffer | Uint8Array): void;
-    isSubscribed(topic: string): boolean;
-    cork(cb: (ws: BunServerWebSocket) => void): void;
-}
-
-declare const WebSocket: {
-    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
-    prototype: WebSocket;
-    readonly CONNECTING: 0;
-    readonly OPEN: 1;
-    readonly CLOSING: 2;
-    readonly CLOSED: 3;
-};
 interface AdapterOptions {
 }
+type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
+    websocket: any;
+}>["websocket"];
 interface Adapter {
-    websocket: BunWSOptions;
+    websocket: WebSocketHooks;
 }
 declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
 
-export { type Adapter, type AdapterOptions, WebSocket, _default as default };
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/bun.d.mts

@@ -1,43 +1,13 @@
 import { WebSocketAdapter } from '../index.mjs';
 
-interface BunWSOptions {
-    message: (ws: BunServerWebSocket, message: string | ArrayBuffer | Uint8Array) => void;
-    open?: (ws: BunServerWebSocket) => void;
-    close?: (ws: BunServerWebSocket) => void;
-    error?: (ws: BunServerWebSocket, error: Error) => void;
-    drain?: (ws: BunServerWebSocket) => void;
-    perMessageDeflate?: boolean | {
-        compress?: boolean | BunWSCompressor;
-        decompress?: boolean | BunWSCompressor;
-    };
-}
-type BunWSCompressor = `"disable"` | `"shared"` | `"dedicated"` | `"3KB"` | `"4KB"` | `"8KB"` | `"16KB"` | `"32KB"` | `"64KB"` | `"128KB"` | `"256KB"`;
-interface BunServerWebSocket {
-    readonly data: any;
-    readonly readyState: number;
-    readonly remoteAddress: string;
-    send(message: string | ArrayBuffer | Uint8Array, compress?: boolean): number;
-    close(code?: number, reason?: string): void;
-    subscribe(topic: string): void;
-    unsubscribe(topic: string): void;
-    publish(topic: string, message: string | ArrayBuffer | Uint8Array): void;
-    isSubscribed(topic: string): boolean;
-    cork(cb: (ws: BunServerWebSocket) => void): void;
-}
-
-declare const WebSocket: {
-    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
-    prototype: WebSocket;
-    readonly CONNECTING: 0;
-    readonly OPEN: 1;
-    readonly CLOSING: 2;
-    readonly CLOSED: 3;
-};
 interface AdapterOptions {
 }
+type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
+    websocket: any;
+}>["websocket"];
 interface Adapter {
-    websocket: BunWSOptions;
+    websocket: WebSocketHooks;
 }
 declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
 
-export { type Adapter, type AdapterOptions, WebSocket, _default as default };
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/bun.d.ts

@@ -1,43 +1,13 @@
 import { WebSocketAdapter } from '../index.js';
 
-interface BunWSOptions {
-    message: (ws: BunServerWebSocket, message: string | ArrayBuffer | Uint8Array) => void;
-    open?: (ws: BunServerWebSocket) => void;
-    close?: (ws: BunServerWebSocket) => void;
-    error?: (ws: BunServerWebSocket, error: Error) => void;
-    drain?: (ws: BunServerWebSocket) => void;
-    perMessageDeflate?: boolean | {
-        compress?: boolean | BunWSCompressor;
-        decompress?: boolean | BunWSCompressor;
-    };
-}
-type BunWSCompressor = `"disable"` | `"shared"` | `"dedicated"` | `"3KB"` | `"4KB"` | `"8KB"` | `"16KB"` | `"32KB"` | `"64KB"` | `"128KB"` | `"256KB"`;
-interface BunServerWebSocket {
-    readonly data: any;
-    readonly readyState: number;
-    readonly remoteAddress: string;
-    send(message: string | ArrayBuffer | Uint8Array, compress?: boolean): number;
-    close(code?: number, reason?: string): void;
-    subscribe(topic: string): void;
-    unsubscribe(topic: string): void;
-    publish(topic: string, message: string | ArrayBuffer | Uint8Array): void;
-    isSubscribed(topic: string): boolean;
-    cork(cb: (ws: BunServerWebSocket) => void): void;
-}
-
-declare const WebSocket: {
-    new (url: string | URL, protocols?: string | string[] | undefined): WebSocket;
-    prototype: WebSocket;
-    readonly CONNECTING: 0;
-    readonly OPEN: 1;
-    readonly CLOSING: 2;
-    readonly CLOSED: 3;
-};
 interface AdapterOptions {
 }
+type WebSocketHooks = Extract<Parameters<typeof Bun.serve<ContextData>>[0], {
+    websocket: any;
+}>["websocket"];
 interface Adapter {
-    websocket: BunWSOptions;
+    websocket: WebSocketHooks;
 }
 declare const _default: WebSocketAdapter<Adapter, AdapterOptions>;
 
-export { type Adapter, type AdapterOptions, WebSocket, _default as default };
+export { type Adapter, type AdapterOptions, _default as default };

package/dist/adapters/bun.mjs

@@ -1,52 +1,70 @@
-import { d as defineWebSocketAdapter, a as WebSocketMessage, W as WebSocketError, b as WebSocketPeer } from '../shared/crossws.08866fa6.mjs';
+import { d as defineWebSocketAdapter, a as WebSocketMessage, W as WebSocketError, b as WebSocketPeerBase } from '../shared/crossws.9536f626.mjs';
 
-const WebSocket = globalThis.WebSocket;
 const bun = defineWebSocketAdapter(
-  (handler, opts = {}) => {
+  (hooks, opts = {}) => {
+    const getPeer = (ws) => {
+      if (ws.data?._peer) {
+        return ws.data._peer;
+      }
+      const peer = new WebSocketPeer({ bun: { ws } });
+      ws.data = ws.data || {};
+      ws.data._peer = peer;
+      return peer;
+    };
     return {
       websocket: {
         message: (ws, message) => {
-          handler.onEvent?.("bun:message", ws, message);
-          const peer = new BunWebSocketPeer(ws);
-          handler.onMessage?.(peer, new WebSocketMessage(message));
+          const peer = getPeer(ws);
+          hooks["bun:message"]?.(peer, ws, message);
+          hooks.message?.(peer, new WebSocketMessage(message));
         },
         open: (ws) => {
-          handler.onEvent?.("bun:open", ws);
-          const peer = new BunWebSocketPeer(ws);
-          handler.onOpen?.(peer);
+          const peer = getPeer(ws);
+          hooks["bun:open"]?.(peer, ws);
+          hooks.open?.(peer);
         },
         close: (ws) => {
-          handler.onEvent?.("bun:close", ws);
-          const peer = new BunWebSocketPeer(ws);
-          handler.onClose?.(peer, 0, "");
+          const peer = getPeer(ws);
+          hooks["bun:close"]?.(peer, ws);
+          hooks.close?.(peer, {});
+        },
+        drain: (ws) => {
+          const peer = getPeer(ws);
+          hooks["bun:drain"]?.(peer);
         },
+        // @ts-expect-error types unavailable but mentioned in docs
         error: (ws, error) => {
-          handler.onEvent?.("bun:error", ws, error);
-          const peer = new BunWebSocketPeer(ws);
-          handler.onError?.(peer, new WebSocketError(error));
+          const peer = getPeer(ws);
+          hooks["bun:error"]?.(peer, ws, error);
+          hooks.error?.(peer, new WebSocketError(error));
         },
-        drain: (ws) => {
-          handler.onEvent?.("bun:drain", ws);
+        ping(ws, data) {
+          const peer = getPeer(ws);
+          hooks["bun:ping"]?.(peer, ws, data);
+        },
+        pong(ws, data) {
+          const peer = getPeer(ws);
+          hooks["bun:pong"]?.(peer, ws, data);
         }
       }
     };
   }
 );
-class BunWebSocketPeer extends WebSocketPeer {
-  constructor(_ws) {
-    super();
-    this._ws = _ws;
-  }
+class WebSocketPeer extends WebSocketPeerBase {
   get id() {
-    return this._ws.remoteAddress;
+    let addr = this.ctx.bun.ws.remoteAddress;
+    if (addr.includes(":")) {
+      addr = `[${addr}]`;
+    }
+    return addr;
   }
   get readyState() {
-    return this._ws.readyState;
+    return this.ctx.bun.ws.readyState;
   }
   send(message) {
-    this._ws.send(message);
+    this.ctx.bun.ws.send(message);
     return 0;
   }
 }
 
-export { WebSocket, bun as default };
+export { bun as default };