@kyneta/websocket-transport 1.3.1 → 1.5.0

package/dist/browser.d.ts

@@ -1,50 +1,50 @@
-import { Program } from '@kyneta/machine';
-import { ReconnectOptions } from '@kyneta/transport';
-import { W as WebsocketClientState } from './types-D0lbeevu.js';
-export { D as DisconnectReason, R as READY_STATE, S as Socket, a as SocketReadyState, T as TransitionListener, b as WebSocketCloseEvent, c as WebSocketConstructor, d as WebSocketLike, e as WebSocketMessageEvent, f as WebsocketClientStateTransition } from './types-D0lbeevu.js';
-export { D as DEFAULT_FRAGMENT_THRESHOLD, W as WebsocketClientLifecycleEvents, a as WebsocketClientOptions, b as WebsocketClientTransport, c as createWebsocketClient } from './client-transport-DUAFjVbh.js';
+import { a as SocketReadyState, c as WebSocketConstructor, d as WebsocketClientState, f as WebsocketClientStateTransition, i as Socket, l as WebSocketLike, o as TransitionListener, r as READY_STATE, s as WebSocketCloseEvent, t as DisconnectReason, u as WebSocketMessageEvent } from "./types-c1S_xIRG.js";
+import { a as createWebsocketClient, i as WebsocketClientTransport, n as WebsocketClientLifecycleEvents, r as WebsocketClientOptions, t as DEFAULT_FRAGMENT_THRESHOLD } from "./client-transport-D3tYQYrS.js";
+import { ReconnectOptions } from "@kyneta/transport";
+import { Program } from "@kyneta/machine";
 
+//#region src/client-program.d.ts
 type WsClientMsg = {
-    type: "start";
+  type: "start";
 } | {
-    type: "socket-opened";
+  type: "socket-opened";
 } | {
-    type: "server-ready";
+  type: "server-ready";
 } | {
-    type: "socket-closed";
-    code: number;
-    reason: string;
+  type: "socket-closed";
+  code: number;
+  reason: string;
 } | {
-    type: "socket-error";
-    error: Error;
+  type: "socket-error";
+  error: Error;
 } | {
-    type: "reconnect-timer-fired";
+  type: "reconnect-timer-fired";
 } | {
-    type: "stop";
+  type: "stop";
 };
 type WsClientEffect = {
-    type: "create-websocket";
-    attempt: number;
+  type: "create-websocket";
+  attempt: number;
 } | {
-    type: "close-websocket";
+  type: "close-websocket";
 } | {
-    type: "add-channel-and-establish";
+  type: "add-channel-and-establish";
 } | {
-    type: "remove-channel";
+  type: "remove-channel";
 } | {
-    type: "start-reconnect-timer";
-    delayMs: number;
+  type: "start-reconnect-timer";
+  delayMs: number;
 } | {
-    type: "cancel-reconnect-timer";
+  type: "cancel-reconnect-timer";
 } | {
-    type: "start-keepalive";
+  type: "start-keepalive";
 } | {
-    type: "stop-keepalive";
+  type: "stop-keepalive";
 };
 interface WsClientProgramOptions {
-    reconnect?: Partial<ReconnectOptions>;
-    /** Inject jitter source for deterministic testing. Default: () => Math.random() * 1000 */
-    jitterFn?: () => number;
+  reconnect?: Partial<ReconnectOptions>;
+  /** Inject jitter source for deterministic testing. Default: () => Math.random() * 1000 */
+  jitterFn?: () => number;
 }
 /**
  * Create the websocket client connection lifecycle program — a pure Mealy machine.
@@ -54,5 +54,6 @@ interface WsClientProgramOptions {
  * shell interprets `WsClientEffect` as actual I/O.
  */
 declare function createWsClientProgram(options?: WsClientProgramOptions): Program<WsClientMsg, WebsocketClientState, WsClientEffect>;
-
-export { WebsocketClientState, type WsClientEffect, type WsClientMsg, type WsClientProgramOptions, createWsClientProgram };
+//#endregion
+export { DEFAULT_FRAGMENT_THRESHOLD, type DisconnectReason, READY_STATE, type Socket, type SocketReadyState, type TransitionListener, type WebSocketCloseEvent, type WebSocketConstructor, type WebSocketLike, type WebSocketMessageEvent, type WebsocketClientLifecycleEvents, type WebsocketClientOptions, type WebsocketClientState, type WebsocketClientStateTransition, WebsocketClientTransport, type WsClientEffect, type WsClientMsg, type WsClientProgramOptions, createWebsocketClient, createWsClientProgram };
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","names":[],"sources":["../src/client-program.ts"],"mappings":";;;;;;KA4BY,WAAA;EACN,IAAA;AAAA;EACA,IAAA;AAAA;EACA,IAAA;AAAA;EACA,IAAA;EAAuB,IAAA;EAAc,MAAA;AAAA;EACrC,IAAA;EAAsB,KAAA,EAAO,KAAA;AAAA;EAC7B,IAAA;AAAA;EACA,IAAA;AAAA;AAAA,KAMM,cAAA;EACN,IAAA;EAA0B,OAAA;AAAA;EAC1B,IAAA;AAAA;EACA,IAAA;AAAA;EACA,IAAA;AAAA;EACA,IAAA;EAA+B,OAAA;AAAA;EAC/B,IAAA;AAAA;EACA,IAAA;AAAA;EACA,IAAA;AAAA;AAAA,UAMW,sBAAA;EACf,SAAA,GAAY,OAAA,CAAQ,gBAAA;EAAD;EAEnB,QAAA;AAAA;;;;;AAUF;;;iBAAgB,qBAAA,CACd,OAAA,GAAS,sBAAA,GACR,OAAA,CAAQ,WAAA,EAAa,oBAAA,EAAsB,cAAA"}

package/dist/browser.js

@@ -1,15 +1,2 @@
-import {
-  DEFAULT_FRAGMENT_THRESHOLD,
-  READY_STATE,
-  WebsocketClientTransport,
-  createWebsocketClient,
-  createWsClientProgram
-} from "./chunk-YZQF5RLV.js";
-export {
-  DEFAULT_FRAGMENT_THRESHOLD,
-  READY_STATE,
-  WebsocketClientTransport,
-  createWebsocketClient,
-  createWsClientProgram
-};
-//# sourceMappingURL=browser.js.map
+import { i as READY_STATE, n as WebsocketClientTransport, r as createWebsocketClient, s as createWsClientProgram, t as DEFAULT_FRAGMENT_THRESHOLD } from "./client-transport-B2V7s2VP.js";
+export { DEFAULT_FRAGMENT_THRESHOLD, READY_STATE, WebsocketClientTransport, createWebsocketClient, createWsClientProgram };

package/dist/bun.d.ts

@@ -1,8 +1,7 @@
-import { ServerWebSocket } from 'bun';
-import { S as Socket } from './types-D0lbeevu.js';
-export { D as DisconnectReason, a as SocketReadyState } from './types-D0lbeevu.js';
-import '@kyneta/transport';
+import { a as SocketReadyState, i as Socket, t as DisconnectReason } from "./types-c1S_xIRG.js";
+import { ServerWebSocket } from "bun";
 
+//#region src/bun-websocket.d.ts
 /**
  * Data structure stored in `ws.data` for handler callbacks.
  * Use this type when defining your `Bun.serve()` generic.
@@ -15,10 +14,10 @@ import '@kyneta/transport';
  * ```
  */
 type BunWebsocketData = {
-    handlers: {
-        onMessage?: (data: Uint8Array | string) => void;
-        onClose?: (code: number, reason: string) => void;
-    };
+  handlers: {
+    onMessage?: (data: Uint8Array<ArrayBuffer> | string) => void;
+    onClose?: (code: number, reason: string) => void;
+  };
 };
 /**
  * Wrap Bun's `ServerWebSocket` to match the `Socket` interface.
@@ -77,15 +76,16 @@ declare function wrapBunWebsocket(ws: ServerWebSocket<BunWebsocketData>): Socket
  * ```
  */
 declare function createBunWebsocketHandlers(wsAdapter: {
-    handleConnection: (opts: {
-        socket: Socket;
-    }) => {
-        start: () => void;
-    };
+  handleConnection: (opts: {
+    socket: Socket;
+  }) => {
+    start: () => void;
+  };
 }): {
-    open(ws: ServerWebSocket<BunWebsocketData>): void;
-    message(ws: ServerWebSocket<BunWebsocketData>, msg: string | ArrayBuffer | Buffer): void;
-    close(ws: ServerWebSocket<BunWebsocketData>, code: number, reason: string): void;
+  open(ws: ServerWebSocket<BunWebsocketData>): void;
+  message(ws: ServerWebSocket<BunWebsocketData>, msg: string | ArrayBuffer | Buffer): void;
+  close(ws: ServerWebSocket<BunWebsocketData>, code: number, reason: string): void;
 };
-
-export { type BunWebsocketData, Socket, createBunWebsocketHandlers, wrapBunWebsocket };
+//#endregion
+export { type BunWebsocketData, type DisconnectReason, type Socket, type SocketReadyState, createBunWebsocketHandlers, wrapBunWebsocket };
+//# sourceMappingURL=bun.d.ts.map

package/dist/bun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.d.ts","names":[],"sources":["../src/bun-websocket.ts"],"mappings":";;;;;;AA+BA;;;;;;;;;KAAY,gBAAA;EACV,QAAA;IACE,SAAA,IAAa,IAAA,EAAM,UAAA,CAAW,WAAA;IAC9B,OAAA,IAAW,IAAA,UAAc,MAAA;EAAA;AAAA;;;;;;;;;;;;;;AAyG7B;;;;;;;;;;;;;;;;;;;iBAjEgB,gBAAA,CACd,EAAA,EAAI,eAAA,CAAgB,gBAAA,IACnB,MAAA;;;;;;;;;;;;;;;;;;;;;;;;iBA+Da,0BAAA,CAA2B,SAAA;EACzC,gBAAA,GAAmB,IAAA;IAAQ,MAAA,EAAQ,MAAA;EAAA;IAAe,KAAA;EAAA;AAAA;WAGvC,eAAA,CAAgB,gBAAA;cAInB,eAAA,CAAgB,gBAAA,GAAiB,GAAA,WACvB,WAAA,GAAc,MAAA;YAUpB,eAAA,CAAgB,gBAAA,GAAiB,IAAA,UAAc,MAAA;AAAA"}

package/dist/bun.js

@@ -1,48 +1,100 @@
-// src/bun-websocket.ts
+//#region src/bun-websocket.ts
+/**
+* Wrap Bun's `ServerWebSocket` to match the `Socket` interface.
+*
+* Bun's WebSocket API uses server-level callbacks (`websocket: { message, close }`)
+* rather than per-socket event handlers. This wrapper bridges that gap by
+* storing handlers in `ws.data` and having the server-level callbacks delegate
+* to them.
+*
+* @example
+* ```typescript
+* import { WebsocketServerTransport } from "@kyneta/websocket-transport/server"
+* import { wrapBunWebsocket, type BunWebsocketData } from "@kyneta/websocket-transport/bun"
+*
+* const serverAdapter = new WebsocketServerTransport()
+*
+* Bun.serve<BunWebsocketData>({
+*   websocket: {
+*     open(ws) {
+*       const socket = wrapBunWebsocket(ws)
+*       serverAdapter.handleConnection({ socket }).start()
+*     },
+*     message(ws, msg) {
+*       const data = msg instanceof ArrayBuffer ? new Uint8Array(msg) : msg
+*       ws.data?.handlers?.onMessage?.(data)
+*     },
+*     close(ws, code, reason) {
+*       ws.data?.handlers?.onClose?.(code, reason)
+*     },
+*   },
+* })
+* ```
+*/
 function wrapBunWebsocket(ws) {
-  ws.data = { handlers: {} };
-  return {
-    send(data) {
-      ws.send(data);
-    },
-    close(code, reason) {
-      ws.close(code, reason);
-    },
-    onMessage(handler) {
-      ws.data.handlers.onMessage = handler;
-    },
-    onClose(handler) {
-      ws.data.handlers.onClose = handler;
-    },
-    onError(_handler) {
-    },
-    get readyState() {
-      const states = [
-        "connecting",
-        "open",
-        "closing",
-        "closed"
-      ];
-      return states[ws.readyState] ?? "closed";
-    }
-  };
+	ws.data = { handlers: {} };
+	return {
+		send(data) {
+			ws.send(data);
+		},
+		close(code, reason) {
+			ws.close(code, reason);
+		},
+		onMessage(handler) {
+			ws.data.handlers.onMessage = handler;
+		},
+		onClose(handler) {
+			ws.data.handlers.onClose = handler;
+		},
+		onError(_handler) {},
+		get readyState() {
+			return [
+				"connecting",
+				"open",
+				"closing",
+				"closed"
+			][ws.readyState] ?? "closed";
+		}
+	};
 }
+/**
+* Create Bun Websocket handlers that integrate with `WebsocketServerTransport`.
+*
+* This helper eliminates boilerplate by providing pre-configured handlers
+* for `open`, `message`, and `close` events that automatically wire up
+* to the adapter's `handleConnection()` method.
+*
+* @example
+* ```typescript
+* import { WebsocketServerTransport } from "@kyneta/websocket-transport/server"
+* import { createBunWebsocketHandlers, type BunWebsocketData } from "@kyneta/websocket-transport/bun"
+*
+* const serverAdapter = new WebsocketServerTransport()
+*
+* Bun.serve<BunWebsocketData>({
+*   fetch(req, server) {
+*     server.upgrade(req)
+*     return new Response("upgrade failed", { status: 400 })
+*   },
+*   websocket: createBunWebsocketHandlers(serverAdapter),
+* })
+* ```
+*/
 function createBunWebsocketHandlers(wsAdapter) {
-  return {
-    open(ws) {
-      wsAdapter.handleConnection({ socket: wrapBunWebsocket(ws) }).start();
-    },
-    message(ws, msg) {
-      const data = msg instanceof ArrayBuffer ? new Uint8Array(msg) : Buffer.isBuffer(msg) ? new Uint8Array(msg) : msg;
-      ws.data.handlers.onMessage?.(data);
-    },
-    close(ws, code, reason) {
-      ws.data.handlers.onClose?.(code, reason);
-    }
-  };
+	return {
+		open(ws) {
+			wsAdapter.handleConnection({ socket: wrapBunWebsocket(ws) }).start();
+		},
+		message(ws, msg) {
+			const data = msg instanceof ArrayBuffer ? new Uint8Array(msg) : Buffer.isBuffer(msg) ? new Uint8Array(msg) : msg;
+			ws.data.handlers.onMessage?.(data);
+		},
+		close(ws, code, reason) {
+			ws.data.handlers.onClose?.(code, reason);
+		}
+	};
 }
-export {
-  createBunWebsocketHandlers,
-  wrapBunWebsocket
-};
+//#endregion
+export { createBunWebsocketHandlers, wrapBunWebsocket };
+
 //# sourceMappingURL=bun.js.map

package/dist/bun.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/bun-websocket.ts"],"sourcesContent":["// bun-websocket — Bun-specific Websocket wrapper for @kyneta/websocket-transport.\n//\n// Provides a wrapper to adapt Bun's ServerWebSocket to the Socket interface\n// expected by WebsocketServerTransport.\n//\n// Bun's WebSocket API is callback-based at the server level (not per-socket),\n// so we bridge that gap by storing handlers in ws.data.\n//\n// Ported from @loro-extended/adapter-websocket's bun.ts with kyneta\n// naming conventions applied.\n\n/// <reference types=\"bun-types\" />\n\nimport type { ServerWebSocket } from \"bun\"\nimport type { Socket, SocketReadyState } from \"./types.js\"\n\n// ---------------------------------------------------------------------------\n// BunWebsocketData — stored in ws.data for per-socket handler callbacks\n// ---------------------------------------------------------------------------\n\n/**\n * Data structure stored in `ws.data` for handler callbacks.\n * Use this type when defining your `Bun.serve()` generic.\n *\n * @example\n * ```typescript\n * Bun.serve<BunWebsocketData>({\n *   websocket: { ... }\n * })\n * ```\n */\nexport type BunWebsocketData = {\n  handlers: {\n    onMessage?: (data: Uint8Array | string) => void\n    onClose?: (code: number, reason: string) => void\n  }\n}\n\n// ---------------------------------------------------------------------------\n// wrapBunWebsocket\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap Bun's `ServerWebSocket` to match the `Socket` interface.\n *\n * Bun's WebSocket API uses server-level callbacks (`websocket: { message, close }`)\n * rather than per-socket event handlers. This wrapper bridges that gap by\n * storing handlers in `ws.data` and having the server-level callbacks delegate\n * to them.\n *\n * @example\n * ```typescript\n * import { WebsocketServerTransport } from \"@kyneta/websocket-transport/server\"\n * import { wrapBunWebsocket, type BunWebsocketData } from \"@kyneta/websocket-transport/bun\"\n *\n * const serverAdapter = new WebsocketServerTransport()\n *\n * Bun.serve<BunWebsocketData>({\n *   websocket: {\n *     open(ws) {\n *       const socket = wrapBunWebsocket(ws)\n *       serverAdapter.handleConnection({ socket }).start()\n *     },\n *     message(ws, msg) {\n *       const data = msg instanceof ArrayBuffer ? new Uint8Array(msg) : msg\n *       ws.data?.handlers?.onMessage?.(data)\n *     },\n *     close(ws, code, reason) {\n *       ws.data?.handlers?.onClose?.(code, reason)\n *     },\n *   },\n * })\n * ```\n */\nexport function wrapBunWebsocket(\n  ws: ServerWebSocket<BunWebsocketData>,\n): Socket {\n  ws.data = { handlers: {} }\n\n  return {\n    send(data: Uint8Array | string): void {\n      ws.send(data)\n    },\n\n    close(code?: number, reason?: string): void {\n      ws.close(code, reason)\n    },\n\n    onMessage(handler: (data: Uint8Array | string) => void): void {\n      ws.data.handlers.onMessage = handler\n    },\n\n    onClose(handler: (code: number, reason: string) => void): void {\n      ws.data.handlers.onClose = handler\n    },\n\n    onError(_handler: (error: Error) => void): void {\n      // Bun handles errors at the server level, not per-socket\n    },\n\n    get readyState(): SocketReadyState {\n      const states: SocketReadyState[] = [\n        \"connecting\",\n        \"open\",\n        \"closing\",\n        \"closed\",\n      ]\n      return states[ws.readyState] ?? \"closed\"\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// createBunWebsocketHandlers\n// ---------------------------------------------------------------------------\n\n/**\n * Create Bun Websocket handlers that integrate with `WebsocketServerTransport`.\n *\n * This helper eliminates boilerplate by providing pre-configured handlers\n * for `open`, `message`, and `close` events that automatically wire up\n * to the adapter's `handleConnection()` method.\n *\n * @example\n * ```typescript\n * import { WebsocketServerTransport } from \"@kyneta/websocket-transport/server\"\n * import { createBunWebsocketHandlers, type BunWebsocketData } from \"@kyneta/websocket-transport/bun\"\n *\n * const serverAdapter = new WebsocketServerTransport()\n *\n * Bun.serve<BunWebsocketData>({\n *   fetch(req, server) {\n *     server.upgrade(req)\n *     return new Response(\"upgrade failed\", { status: 400 })\n *   },\n *   websocket: createBunWebsocketHandlers(serverAdapter),\n * })\n * ```\n */\nexport function createBunWebsocketHandlers(wsAdapter: {\n  handleConnection: (opts: { socket: Socket }) => { start: () => void }\n}) {\n  return {\n    open(ws: ServerWebSocket<BunWebsocketData>) {\n      wsAdapter.handleConnection({ socket: wrapBunWebsocket(ws) }).start()\n    },\n    message(\n      ws: ServerWebSocket<BunWebsocketData>,\n      msg: string | ArrayBuffer | Buffer,\n    ) {\n      const data =\n        msg instanceof ArrayBuffer\n          ? new Uint8Array(msg)\n          : Buffer.isBuffer(msg)\n            ? new Uint8Array(msg)\n            : msg\n      ws.data.handlers.onMessage?.(data)\n    },\n    close(ws: ServerWebSocket<BunWebsocketData>, code: number, reason: string) {\n      ws.data.handlers.onClose?.(code, reason)\n    },\n  }\n}\n"],"mappings":";AA0EO,SAAS,iBACd,IACQ;AACR,KAAG,OAAO,EAAE,UAAU,CAAC,EAAE;AAEzB,SAAO;AAAA,IACL,KAAK,MAAiC;AACpC,SAAG,KAAK,IAAI;AAAA,IACd;AAAA,IAEA,MAAM,MAAe,QAAuB;AAC1C,SAAG,MAAM,MAAM,MAAM;AAAA,IACvB;AAAA,IAEA,UAAU,SAAoD;AAC5D,SAAG,KAAK,SAAS,YAAY;AAAA,IAC/B;AAAA,IAEA,QAAQ,SAAuD;AAC7D,SAAG,KAAK,SAAS,UAAU;AAAA,IAC7B;AAAA,IAEA,QAAQ,UAAwC;AAAA,IAEhD;AAAA,IAEA,IAAI,aAA+B;AACjC,YAAM,SAA6B;AAAA,QACjC;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACF;AACA,aAAO,OAAO,GAAG,UAAU,KAAK;AAAA,IAClC;AAAA,EACF;AACF;AA6BO,SAAS,2BAA2B,WAExC;AACD,SAAO;AAAA,IACL,KAAK,IAAuC;AAC1C,gBAAU,iBAAiB,EAAE,QAAQ,iBAAiB,EAAE,EAAE,CAAC,EAAE,MAAM;AAAA,IACrE;AAAA,IACA,QACE,IACA,KACA;AACA,YAAM,OACJ,eAAe,cACX,IAAI,WAAW,GAAG,IAClB,OAAO,SAAS,GAAG,IACjB,IAAI,WAAW,GAAG,IAClB;AACR,SAAG,KAAK,SAAS,YAAY,IAAI;AAAA,IACnC;AAAA,IACA,MAAM,IAAuC,MAAc,QAAgB;AACzE,SAAG,KAAK,SAAS,UAAU,MAAM,MAAM;AAAA,IACzC;AAAA,EACF;AACF;","names":[]}
+{"version":3,"file":"bun.js","names":[],"sources":["../src/bun-websocket.ts"],"sourcesContent":["// bun-websocket — Bun-specific Websocket wrapper for @kyneta/websocket-transport.\n//\n// Provides a wrapper to adapt Bun's ServerWebSocket to the Socket interface\n// expected by WebsocketServerTransport.\n//\n// Bun's WebSocket API is callback-based at the server level (not per-socket),\n// so we bridge that gap by storing handlers in ws.data.\n//\n// Ported from @loro-extended/adapter-websocket's bun.ts with kyneta\n// naming conventions applied.\n\n/// <reference types=\"bun-types\" />\n\nimport type { ServerWebSocket } from \"bun\"\nimport type { Socket, SocketReadyState } from \"./types.js\"\n\n// ---------------------------------------------------------------------------\n// BunWebsocketData — stored in ws.data for per-socket handler callbacks\n// ---------------------------------------------------------------------------\n\n/**\n * Data structure stored in `ws.data` for handler callbacks.\n * Use this type when defining your `Bun.serve()` generic.\n *\n * @example\n * ```typescript\n * Bun.serve<BunWebsocketData>({\n *   websocket: { ... }\n * })\n * ```\n */\nexport type BunWebsocketData = {\n  handlers: {\n    onMessage?: (data: Uint8Array<ArrayBuffer> | string) => void\n    onClose?: (code: number, reason: string) => void\n  }\n}\n\n// ---------------------------------------------------------------------------\n// wrapBunWebsocket\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap Bun's `ServerWebSocket` to match the `Socket` interface.\n *\n * Bun's WebSocket API uses server-level callbacks (`websocket: { message, close }`)\n * rather than per-socket event handlers. This wrapper bridges that gap by\n * storing handlers in `ws.data` and having the server-level callbacks delegate\n * to them.\n *\n * @example\n * ```typescript\n * import { WebsocketServerTransport } from \"@kyneta/websocket-transport/server\"\n * import { wrapBunWebsocket, type BunWebsocketData } from \"@kyneta/websocket-transport/bun\"\n *\n * const serverAdapter = new WebsocketServerTransport()\n *\n * Bun.serve<BunWebsocketData>({\n *   websocket: {\n *     open(ws) {\n *       const socket = wrapBunWebsocket(ws)\n *       serverAdapter.handleConnection({ socket }).start()\n *     },\n *     message(ws, msg) {\n *       const data = msg instanceof ArrayBuffer ? new Uint8Array(msg) : msg\n *       ws.data?.handlers?.onMessage?.(data)\n *     },\n *     close(ws, code, reason) {\n *       ws.data?.handlers?.onClose?.(code, reason)\n *     },\n *   },\n * })\n * ```\n */\nexport function wrapBunWebsocket(\n  ws: ServerWebSocket<BunWebsocketData>,\n): Socket {\n  ws.data = { handlers: {} }\n\n  return {\n    send(data: Uint8Array<ArrayBuffer> | string): void {\n      ws.send(data)\n    },\n\n    close(code?: number, reason?: string): void {\n      ws.close(code, reason)\n    },\n\n    onMessage(handler: (data: Uint8Array<ArrayBuffer> | string) => void): void {\n      ws.data.handlers.onMessage = handler\n    },\n\n    onClose(handler: (code: number, reason: string) => void): void {\n      ws.data.handlers.onClose = handler\n    },\n\n    onError(_handler: (error: Error) => void): void {\n      // Bun handles errors at the server level, not per-socket\n    },\n\n    get readyState(): SocketReadyState {\n      const states: SocketReadyState[] = [\n        \"connecting\",\n        \"open\",\n        \"closing\",\n        \"closed\",\n      ]\n      return states[ws.readyState] ?? \"closed\"\n    },\n  }\n}\n\n// ---------------------------------------------------------------------------\n// createBunWebsocketHandlers\n// ---------------------------------------------------------------------------\n\n/**\n * Create Bun Websocket handlers that integrate with `WebsocketServerTransport`.\n *\n * This helper eliminates boilerplate by providing pre-configured handlers\n * for `open`, `message`, and `close` events that automatically wire up\n * to the adapter's `handleConnection()` method.\n *\n * @example\n * ```typescript\n * import { WebsocketServerTransport } from \"@kyneta/websocket-transport/server\"\n * import { createBunWebsocketHandlers, type BunWebsocketData } from \"@kyneta/websocket-transport/bun\"\n *\n * const serverAdapter = new WebsocketServerTransport()\n *\n * Bun.serve<BunWebsocketData>({\n *   fetch(req, server) {\n *     server.upgrade(req)\n *     return new Response(\"upgrade failed\", { status: 400 })\n *   },\n *   websocket: createBunWebsocketHandlers(serverAdapter),\n * })\n * ```\n */\nexport function createBunWebsocketHandlers(wsAdapter: {\n  handleConnection: (opts: { socket: Socket }) => { start: () => void }\n}) {\n  return {\n    open(ws: ServerWebSocket<BunWebsocketData>) {\n      wsAdapter.handleConnection({ socket: wrapBunWebsocket(ws) }).start()\n    },\n    message(\n      ws: ServerWebSocket<BunWebsocketData>,\n      msg: string | ArrayBuffer | Buffer,\n    ) {\n      const data =\n        msg instanceof ArrayBuffer\n          ? new Uint8Array(msg)\n          : Buffer.isBuffer(msg)\n            ? new Uint8Array(msg)\n            : msg\n      ws.data.handlers.onMessage?.(data)\n    },\n    close(ws: ServerWebSocket<BunWebsocketData>, code: number, reason: string) {\n      ws.data.handlers.onClose?.(code, reason)\n    },\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,SAAgB,iBACd,IACQ;AACR,IAAG,OAAO,EAAE,UAAU,EAAE,EAAE;AAE1B,QAAO;EACL,KAAK,MAA8C;AACjD,MAAG,KAAK,KAAK;;EAGf,MAAM,MAAe,QAAuB;AAC1C,MAAG,MAAM,MAAM,OAAO;;EAGxB,UAAU,SAAiE;AACzE,MAAG,KAAK,SAAS,YAAY;;EAG/B,QAAQ,SAAuD;AAC7D,MAAG,KAAK,SAAS,UAAU;;EAG7B,QAAQ,UAAwC;EAIhD,IAAI,aAA+B;AAOjC,UANmC;IACjC;IACA;IACA;IACA;IACD,CACa,GAAG,eAAe;;EAEnC;;;;;;;;;;;;;;;;;;;;;;;;;AA8BH,SAAgB,2BAA2B,WAExC;AACD,QAAO;EACL,KAAK,IAAuC;AAC1C,aAAU,iBAAiB,EAAE,QAAQ,iBAAiB,GAAG,EAAE,CAAC,CAAC,OAAO;;EAEtE,QACE,IACA,KACA;GACA,MAAM,OACJ,eAAe,cACX,IAAI,WAAW,IAAI,GACnB,OAAO,SAAS,IAAI,GAClB,IAAI,WAAW,IAAI,GACnB;AACR,MAAG,KAAK,SAAS,YAAY,KAAK;;EAEpC,MAAM,IAAuC,MAAc,QAAgB;AACzE,MAAG,KAAK,SAAS,UAAU,MAAM,OAAO;;EAE3C"}