@couch-kit/host 1.3.0 → 1.4.0

package/README.md

@@ -26,10 +26,10 @@ Then install the required peer dependencies:
 
 ```bash
 npx expo install expo-file-system expo-network
-bun add react-native-tcp-socket
+bun add react-native-tcp-socket react-native-nitro-modules
 ```
 
-> **Note:** This library requires Expo modules (`expo-file-system`, `expo-network`) and `react-native-tcp-socket` as peer dependencies. These must be installed in your consumer app. React Native's autolinking will handle native setup automatically.
+> **Note:** This library requires Expo modules (`expo-file-system`, `expo-network`), `react-native-tcp-socket`, and `react-native-nitro-modules` as peer dependencies. These must be installed in your consumer app. React Native's autolinking will handle native setup automatically.
 
 ## Compatibility
 
@@ -45,8 +45,6 @@ bun add react-native-tcp-socket
 
 > **New Architecture:** This package supports React Native's New Architecture (Fabric/TurboModules) via React Native 0.83+.
 
-## Usage
-
 ## API
 
 ### `<GameHostProvider config={...}>`
@@ -71,6 +69,36 @@ Returns:
 - `serverUrl`: HTTP URL phones should open (or `devServerUrl` in dev mode)
 - `serverError`: static server error (if startup fails)
 
+### `useExtractAssets(manifest)`
+
+Extracts bundled web assets from the APK to a writable directory so the native HTTP server can serve them.
+
+On Android, assets live inside the APK and cannot be served directly. This hook copies each file listed in the manifest from the APK to the device filesystem. On iOS, extraction is skipped since assets are accessible from the bundle directory.
+
+```tsx
+import { useExtractAssets } from "@couch-kit/host";
+import manifest from "./www/manifest.json";
+
+function App() {
+  const { staticDir, loading, error } = useExtractAssets(manifest);
+
+  if (loading) return <Text>Extracting assets...</Text>;
+  if (error) return <Text>Error: {error}</Text>;
+
+  return (
+    <GameHostProvider config={{ staticDir, reducer, initialState }}>
+      ...
+    </GameHostProvider>
+  );
+}
+```
+
+| Property    | Type                  | Description                                       |
+| ----------- | --------------------- | ------------------------------------------------- |
+| `staticDir` | `string \| undefined` | Filesystem path to extracted assets, or undefined |
+| `loading`   | `boolean`             | Whether extraction is in progress                 |
+| `error`     | `string \| null`      | Error message if extraction failed                |
+
 ## System Actions
 
 The host automatically dispatches internal system actions (`__PLAYER_JOINED__`, `__PLAYER_LEFT__`, `__PLAYER_RECONNECTED__`, `__PLAYER_REMOVED__`, `__HYDRATE__`) into `createGameReducer`, which handles them for you. **You do not need to handle these in your reducer.**
@@ -161,6 +189,8 @@ To iterate on your web controller without rebuilding the Android app constantly:
 ```tsx
 <GameHostProvider
     config={{
+        reducer: gameReducer,
+        initialState,
         devMode: true,
         devServerUrl: 'http://192.168.1.50:5173' // Your laptop's IP
     }}

package/lib/provider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAQN,MAAM,OAAO,CAAC;AAGf,OAAO,EAQL,KAAK,UAAU,EACf,KAAK,OAAO,EAGb,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO;IACrE,YAAY,EAAE,CAAC,CAAC;IAChB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,+CAA+C;IAC/C,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1D,wCAAwC;IACxC,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,yCAAyC;IACzC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC;AAED,UAAU,oBAAoB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO;IACpE,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;IAC9B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,KAAK,GAAG,IAAI,CAAC;CAC3B;AA4CD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO,EAAE,EACxE,QAAQ,EACR,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC9B,qBAsTA;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO,KAK/C,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,CAC7C"}
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../src/provider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAQN,MAAM,OAAO,CAAC;AAGf,OAAO,EAQL,KAAK,UAAU,EACf,KAAK,OAAO,EAGb,MAAM,iBAAiB,CAAC;AAEzB,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO;IACrE,YAAY,EAAE,CAAC,CAAC;IAChB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,+CAA+C;IAC/C,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1D,wCAAwC;IACxC,YAAY,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1C,yCAAyC;IACzC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;CAClC;AAED,UAAU,oBAAoB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO;IACpE,KAAK,EAAE,CAAC,CAAC;IACT,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,IAAI,CAAC;IAC9B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,WAAW,EAAE,KAAK,GAAG,IAAI,CAAC;CAC3B;AA4CD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO,EAAE,EACxE,QAAQ,EACR,MAAM,GACP,EAAE;IACD,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,MAAM,EAAE,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAC9B,qBA4TA;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,OAAO,KAK/C,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,CAC7C"}

package/lib/websocket.d.ts

@@ -1,9 +1,8 @@
 /**
- * Lightweight WebSocket Server Implementation
- * Built on top of react-native-tcp-socket
+ * WebSocket Server Implementation using nitro-http
  *
- * Supports: text frames, close frames, ping/pong, multi-frame TCP packets,
- * server-side keepalive, frame size limits, and robust buffer management per RFC 6455.
+ * Supports: bidirectional messaging, connection/disconnect events,
+ * and integration with react-native-nitro-http-server's WebSocket plugin.
  */
 import { EventEmitter } from "./event-emitter";
 export interface WebSocketConfig {
@@ -29,20 +28,10 @@ export declare class GameWebSocketServer extends EventEmitter<WebSocketServerEve
     private clients;
     private port;
     private debug;
-    private maxFrameSize;
-    private keepaliveInterval;
-    private keepaliveTimeout;
-    private keepaliveTimer;
     constructor(config: WebSocketConfig);
     private log;
-    start(): void;
-    private startKeepalive;
-    private processFrames;
-    /**
-     * Gracefully stop the server.
-     * Sends close frames to all clients before destroying connections.
-     */
-    stop(): void;
+    start(): Promise<void>;
+    stop(): Promise<void>;
     /**
      * Send data to a specific client by socket ID.
      * Silently ignores unknown socket IDs and write errors.
@@ -50,16 +39,10 @@ export declare class GameWebSocketServer extends EventEmitter<WebSocketServerEve
     send(socketId: string, data: unknown): void;
     /**
      * Broadcast data to all connected clients.
-     * Wraps each write in try/catch so a single dead socket doesn't skip remaining clients.
+     * Wraps each send in try/catch so a single failed send doesn't skip remaining clients.
      */
     broadcast(data: unknown, excludeId?: string): void;
     /** Returns the number of currently connected clients. */
     get clientCount(): number;
-    private handleHandshake;
-    private generateAcceptKey;
-    private decodeFrame;
-    private encodeFrame;
-    private encodeControlFrame;
-    private buildFrame;
 }
 //# sourceMappingURL=websocket.d.ts.map

package/lib/websocket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../src/websocket.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAY/C,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,8CAA8C;AAC9C,MAAM,MAAM,qBAAqB,GAAG;IAClC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC9C,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC1B,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CACvB,CAAC;AAwBF,qBAAa,mBAAoB,SAAQ,YAAY,CAAC,qBAAqB,CAAC;IAC1E,OAAO,CAAC,MAAM,CAA0D;IACxE,OAAO,CAAC,OAAO,CAAyC;IACxD,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAAU;IACvB,OAAO,CAAC,YAAY,CAAS;IAC7B,OAAO,CAAC,iBAAiB,CAAS;IAClC,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,cAAc,CAA+C;gBAEzD,MAAM,EAAE,eAAe;IASnC,OAAO,CAAC,GAAG;IAMJ,KAAK;IAkFZ,OAAO,CAAC,cAAc;IAkCtB,OAAO,CAAC,aAAa;IA6GrB;;;OAGG;IACI,IAAI;IAqCX;;;OAGG;IACI,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;IAgB3C;;;OAGG;IACI,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM;IAclD,yDAAyD;IACzD,IAAW,WAAW,IAAI,MAAM,CAE/B;IAID,OAAO,CAAC,eAAe;IAkDvB,OAAO,CAAC,iBAAiB;IAQzB,OAAO,CAAC,WAAW;IA4DnB,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,kBAAkB;IAI1B,OAAO,CAAC,UAAU;CA2BnB"}
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../src/websocket.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAG/C,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oFAAoF;IACpF,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,6EAA6E;IAC7E,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,8CAA8C;AAC9C,MAAM,MAAM,qBAAqB,GAAG;IAClC,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC/B,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC;IAC9C,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;IAC1B,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;CACvB,CAAC;AAOF,qBAAa,mBAAoB,SAAQ,YAAY,CAAC,qBAAqB,CAAC;IAC1E,OAAO,CAAC,MAAM,CAA6B;IAC3C,OAAO,CAAC,OAAO,CAA2C;IAC1D,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,KAAK,CAAU;gBAEX,MAAM,EAAE,eAAe;IASnC,OAAO,CAAC,GAAG;IAME,KAAK;IA6FL,IAAI;IAoBjB;;;OAGG;IACI,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO;IAsB3C;;;OAGG;IACI,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,SAAS,CAAC,EAAE,MAAM;IAoBlD,yDAAyD;IACzD,IAAW,WAAW,IAAI,MAAM,CAE/B;CACF"}

package/package.json

@@ -1,6 +1,10 @@
 {
   "name": "@couch-kit/host",
-  "version": "1.3.0",
+  "version": "1.4.0",
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "description": "React Native host for local multiplayer party games on Android TV — WebSocket server, state management, and static file serving",
   "license": "MIT",
   "repository": {
@@ -51,7 +55,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@couch-kit/core": "0.5.0",
+    "@couch-kit/core": "0.5.1",
     "buffer": "^6.0.3",
     "js-sha1": "^0.7.0",
     "react-native-nitro-http-server": "^1.5.4"
@@ -69,7 +73,6 @@
     "react-native-nitro-modules": ">=0.33.0",
     "expo": ">=51.0.0",
     "expo-file-system": ">=17.0.0",
-    "expo-network": ">=7.0.0",
-    "react-native-tcp-socket": ">=6.0.0"
+    "expo-network": ">=7.0.0"
   }
 }

package/src/assets.ts

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
 import * as FileSystem from "expo-file-system";
-import { Paths, Directory } from "expo-file-system/next";
+import { Paths, Directory } from "expo-file-system";
 import { Platform } from "react-native";
 import { toErrorMessage } from "@couch-kit/core";
 

package/src/provider.tsx

@@ -185,7 +185,13 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
     const port = config.wsPort || httpPort + DEFAULT_WS_PORT_OFFSET;
     const server = new GameWebSocketServer({ port, debug: config.debug });
 
-    server.start();
+    // Start the WebSocket server asynchronously
+    server.start().catch((error) => {
+      if (configRef.current.debug) {
+        console.error("[GameHost] Failed to start WebSocket server:", error);
+      }
+      configRef.current.onError?.(error);
+    });
     wsServer.current = server;
 
     server.on("listening", (p) => {

package/src/server.ts

@@ -1,6 +1,6 @@
 import { useEffect, useState } from "react";
 import { StaticServer } from "react-native-nitro-http-server";
-import { Paths } from "expo-file-system/next";
+import { Paths } from "expo-file-system";
 import { getBestIpAddress } from "./network";
 import { DEFAULT_HTTP_PORT, toErrorMessage } from "@couch-kit/core";
 
@@ -58,7 +58,7 @@ export const useStaticServer = (config: CouchKitHostConfig) => {
           if (!bundleUri) {
             throw new Error(
               "No staticDir provided and Paths.bundle is unavailable. " +
-              "On Android, you must pass staticDir from useExtractAssets.",
+                "On Android, you must pass staticDir from useExtractAssets.",
             );
           }
           path = `${bundleUri.replace(/^file:\/\//, "")}www`;

package/src/websocket.ts

@@ -1,24 +1,17 @@
 /**
- * Lightweight WebSocket Server Implementation
- * Built on top of react-native-tcp-socket
+ * WebSocket Server Implementation using nitro-http
  *
- * Supports: text frames, close frames, ping/pong, multi-frame TCP packets,
- * server-side keepalive, frame size limits, and robust buffer management per RFC 6455.
+ * Supports: bidirectional messaging, connection/disconnect events,
+ * and integration with react-native-nitro-http-server's WebSocket plugin.
  */
 
-import TcpSocket from "react-native-tcp-socket";
-import type { TcpSocketInstance } from "./declarations";
+import { ConfigServer } from "react-native-nitro-http-server";
+import type {
+  ServerWebSocket,
+  WebSocketConnectionRequest,
+} from "react-native-nitro-http-server";
 import { EventEmitter } from "./event-emitter";
-import { Buffer } from "buffer";
-import { sha1 } from "js-sha1";
-import {
-  generateId,
-  MAX_FRAME_SIZE,
-  KEEPALIVE_INTERVAL,
-  KEEPALIVE_TIMEOUT,
-} from "@couch-kit/core";
-import { appendToBuffer, compactBuffer } from "./buffer-utils";
-import type { ManagedSocket } from "./buffer-utils";
+import { generateId } from "@couch-kit/core";
 
 export interface WebSocketConfig {
   port: number;
@@ -40,45 +33,24 @@ export type WebSocketServerEvents = {
   error: [error: Error];
 };
 
-// WebSocket opcodes (RFC 6455 Section 5.2)
-const OPCODE = {
-  CONTINUATION: 0x0,
-  TEXT: 0x1,
-  BINARY: 0x2,
-  CLOSE: 0x8,
-  PING: 0x9,
-  PONG: 0xa,
-} as const;
-
-// Simple WebSocket Frame Parser/Builder
-const GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
-
-/** Initial capacity for per-client receive buffers. */
-const INITIAL_BUFFER_CAPACITY = 4096;
-
-interface DecodedFrame {
-  opcode: number;
-  payload: Buffer;
-  bytesConsumed: number;
+interface WebSocketClient {
+  id: string;
+  ws: ServerWebSocket;
 }
 
 export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
-  private server: ReturnType<typeof TcpSocket.createServer> | null = null;
-  private clients: Map<string, ManagedSocket> = new Map();
+  private server: ConfigServer | null = null;
+  private clients: Map<string, WebSocketClient> = new Map();
   private port: number;
   private debug: boolean;
-  private maxFrameSize: number;
-  private keepaliveInterval: number;
-  private keepaliveTimeout: number;
-  private keepaliveTimer: ReturnType<typeof setInterval> | null = null;
 
   constructor(config: WebSocketConfig) {
     super();
     this.port = config.port;
     this.debug = !!config.debug;
-    this.maxFrameSize = config.maxFrameSize ?? MAX_FRAME_SIZE;
-    this.keepaliveInterval = config.keepaliveInterval ?? KEEPALIVE_INTERVAL;
-    this.keepaliveTimeout = config.keepaliveTimeout ?? KEEPALIVE_TIMEOUT;
+    // Note: maxFrameSize, keepaliveInterval, and keepaliveTimeout are not directly
+    // configurable in nitro-http WebSocket plugin, but the underlying implementation
+    // handles these concerns automatically.
   }
 
   private log(...args: unknown[]) {
@@ -87,269 +59,116 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
     }
   }
 
-  public start() {
+  public async start() {
     this.log(`[WebSocket] Starting server on port ${this.port}...`);
 
-    this.server = TcpSocket.createServer((rawSocket: TcpSocketInstance) => {
-      const addrInfo = rawSocket.address();
-      const remoteAddr =
-        addrInfo && "address" in addrInfo ? addrInfo.address : "unknown";
-      this.log(`[WebSocket] New connection from ${remoteAddr}`);
-
-      const managed: ManagedSocket = {
-        socket: rawSocket,
-        id: "",
-        isHandshakeComplete: false,
-        buffer: Buffer.alloc(INITIAL_BUFFER_CAPACITY),
-        bufferLength: 0,
-        lastPong: Date.now(),
-      };
-
-      rawSocket.on("data", (data: Buffer | string) => {
-        this.log(
-          `[WebSocket] Received data chunk: ${typeof data === "string" ? data.length : data.length} bytes`,
-        );
-        // Append new data using growing buffer strategy (avoids Buffer.concat per event)
-        const incoming = typeof data === "string" ? Buffer.from(data) : data;
-        appendToBuffer(managed, incoming);
-
-        // Handshake not yet performed?
-        if (!managed.isHandshakeComplete) {
-          const header = managed.buffer.toString(
-            "utf8",
-            0,
-            managed.bufferLength,
-          );
-          const endOfHeader = header.indexOf("\r\n\r\n");
-          if (endOfHeader !== -1) {
-            this.handleHandshake(managed, header);
-            // Compact buffer past the handshake header
-            const headerByteLength = Buffer.byteLength(
-              header.substring(0, endOfHeader + 4),
-              "utf8",
-            );
-            compactBuffer(managed, headerByteLength);
-            managed.isHandshakeComplete = true;
-            // Fall through to process any remaining frames below
-          } else {
-            return;
-          }
-        }
-
-        // Process all complete frames in the buffer
-        this.processFrames(managed);
-      });
-
-      rawSocket.on("error", (error: Error) => {
-        this.emit("error", error);
-      });
-
-      rawSocket.on("close", () => {
-        if (managed.id) {
-          this.clients.delete(managed.id);
-          this.emit("disconnect", managed.id);
-        }
-      });
-    });
-
-    // Handle server-level errors (e.g., port already in use)
-    this.server.on("error", (error: Error) => {
-      this.log("[WebSocket] Server error:", error);
-      this.emit("error", error);
-    });
-
-    this.server.listen({ port: this.port, host: "0.0.0.0" }, () => {
-      this.log(`[WebSocket] Server listening on 0.0.0.0:${this.port}`);
-      this.emit("listening", this.port);
-    });
-
-    // Start keepalive pings if enabled
-    if (this.keepaliveInterval > 0) {
-      this.startKeepalive();
-    }
-  }
-
-  private startKeepalive() {
-    this.keepaliveTimer = setInterval(() => {
-      const now = Date.now();
-      const pingFrame = this.encodeControlFrame(OPCODE.PING, Buffer.alloc(0));
-
-      for (const [id, managed] of this.clients) {
-        // Check if previous keepalive timed out
-        if (
-          now - managed.lastPong >
-          this.keepaliveInterval + this.keepaliveTimeout
-        ) {
-          this.log(`[WebSocket] Keepalive timeout for ${id}, disconnecting`);
-          try {
-            managed.socket.destroy();
-          } catch (error) {
-            this.log(
-              "[WebSocket] Socket already destroyed during keepalive cleanup:",
-              error,
-            );
-          }
-          this.clients.delete(id);
-          this.emit("disconnect", id);
-          continue;
-        }
-
-        try {
-          managed.socket.write(pingFrame);
-        } catch (error) {
-          this.log("[WebSocket] Failed to send keepalive ping:", error);
-        }
-      }
-    }, this.keepaliveInterval);
-  }
-
-  private processFrames(managed: ManagedSocket) {
-    let offset = 0;
+    this.server = new ConfigServer();
 
-    while (offset < managed.bufferLength) {
-      // Create a view of the unconsumed portion for decoding
-      const view = Buffer.from(
-        managed.buffer.buffer,
-        managed.buffer.byteOffset + offset,
-        managed.bufferLength - offset,
-      );
-      let frame: DecodedFrame | null;
-      try {
-        frame = this.decodeFrame(view);
-      } catch (error) {
-        // Frame too large or malformed -- disconnect the client
-        this.log(`[WebSocket] Frame error from ${managed.id}:`, error);
-        try {
-          managed.socket.destroy();
-        } catch (destroyError) {
-          this.log(
-            "[WebSocket] Socket already destroyed after frame error:",
-            destroyError,
-          );
-        }
-        return;
-      }
+    // Register WebSocket handler for the /ws path
+    this.server.onWebSocket(
+      "/ws",
+      (ws: ServerWebSocket, request: WebSocketConnectionRequest) => {
+        const socketId = generateId();
+        this.log(`[WebSocket] New connection: ${socketId}`, request);
 
-      if (!frame) {
-        // Incomplete frame -- keep remaining bytes, wait for more data
-        break;
-      }
+        // Store the client
+        this.clients.set(socketId, { id: socketId, ws });
 
-      // Advance past the consumed frame
-      offset += frame.bytesConsumed;
+        // Emit connection event
+        this.emit("connection", socketId);
 
-      // Handle frame by opcode
-      switch (frame.opcode) {
-        case OPCODE.TEXT: {
+        // Handle incoming messages
+        ws.onmessage = (event: { data: string | ArrayBuffer }) => {
           try {
-            const message = JSON.parse(frame.payload.toString("utf8"));
-            this.emit("message", managed.id, message);
+            const data =
+              typeof event.data === "string"
+                ? event.data
+                : new TextDecoder().decode(event.data);
+            const message = JSON.parse(data);
+            this.emit("message", socketId, message);
           } catch (error) {
-            // Corrupt JSON in a complete frame -- discard this frame, continue processing
             this.log(
-              `[WebSocket] Invalid JSON from ${managed.id}, discarding frame:`,
+              `[WebSocket] Invalid JSON from ${socketId}, discarding:`,
               error,
             );
           }
-          break;
-        }
-
-        case OPCODE.CLOSE: {
-          this.log(`[WebSocket] Close frame from ${managed.id}`);
-          // Send close frame back (RFC 6455 Section 5.5.1)
-          const closeFrame = Buffer.alloc(2);
-          closeFrame[0] = 0x88; // FIN + Close opcode
-          closeFrame[1] = 0x00; // No payload
-          try {
-            managed.socket.write(closeFrame);
-          } catch (error) {
-            this.log("[WebSocket] Failed to send close frame:", error);
-          }
-          managed.socket.destroy();
-          break;
-        }
-
-        case OPCODE.PING: {
-          this.log(`[WebSocket] Ping from ${managed.id}`);
-          // Respond with pong containing the same payload (RFC 6455 Section 5.5.3)
-          const pongFrame = this.encodeControlFrame(OPCODE.PONG, frame.payload);
-          try {
-            managed.socket.write(pongFrame);
-          } catch (error) {
-            this.log("[WebSocket] Failed to send pong:", error);
-          }
-          break;
-        }
-
-        case OPCODE.PONG: {
-          // Update last-seen pong time for keepalive tracking
-          managed.lastPong = Date.now();
-          this.log(`[WebSocket] Pong from ${managed.id}`);
-          break;
-        }
-
-        case OPCODE.BINARY: {
-          // Binary frames not supported -- log and discard
+        };
+
+        // Handle disconnect
+        ws.onclose = (event: {
+          code: number;
+          reason: string;
+          wasClean: boolean;
+        }) => {
           this.log(
-            `[WebSocket] Binary frame from ${managed.id}, not supported -- discarding`,
+            `[WebSocket] Client disconnected: ${socketId}`,
+            event.code,
+            event.reason,
           );
-          break;
-        }
-
-        default: {
-          this.log(
-            `[WebSocket] Unknown opcode 0x${frame.opcode.toString(16)} from ${managed.id}, discarding`,
+          this.clients.delete(socketId);
+          this.emit("disconnect", socketId);
+        };
+
+        // Handle errors
+        ws.onerror = (event: { message: string }) => {
+          this.log(`[WebSocket] Error on ${socketId}:`, event.message);
+          this.emit(
+            "error",
+            new Error(`WebSocket error: ${event.message}`),
           );
-          break;
-        }
-      }
+        };
+      },
+    );
 
-      // If socket was destroyed (e.g., close frame), stop processing
-      if (managed.socket.destroyed) break;
+    // Start the server with WebSocket plugin
+    try {
+      await this.server.start(
+        this.port,
+        async () => {
+          // Dummy HTTP handler - we're only using WebSocket functionality
+          return {
+            statusCode: 404,
+            body: "WebSocket server - use ws:// protocol",
+          };
+        },
+        {
+          mounts: [
+            {
+              type: "websocket",
+              path: "/ws",
+            },
+          ],
+        },
+        "0.0.0.0", // Bind to all interfaces
+      );
+      this.emit("listening", this.port);
+      this.log(`[WebSocket] Server listening on port ${this.port}`);
+    } catch (error) {
+      this.log("[WebSocket] Failed to start server:", error);
+      this.emit(
+        "error",
+        error instanceof Error ? error : new Error(String(error)),
+      );
     }
-
-    // Compact buffer: shift unconsumed bytes to the front
-    compactBuffer(managed, offset);
   }
 
-  /**
-   * Gracefully stop the server.
-   * Sends close frames to all clients before destroying connections.
-   */
-  public stop() {
-    // Stop keepalive timer
-    if (this.keepaliveTimer) {
-      clearInterval(this.keepaliveTimer);
-      this.keepaliveTimer = null;
-    }
-
+  public async stop() {
     if (this.server) {
-      // Send close frames to all clients before destroying
-      const closeFrame = Buffer.alloc(2);
-      closeFrame[0] = 0x88; // FIN + Close opcode
-      closeFrame[1] = 0x00; // No payload
-
-      this.clients.forEach((managed) => {
-        try {
-          managed.socket.write(closeFrame);
-        } catch (error) {
-          this.log(
-            "[WebSocket] Failed to send close frame during shutdown:",
-            error,
-          );
-        }
+      // Close all client connections
+      for (const [, client] of this.clients) {
         try {
-          managed.socket.destroy();
+          await client.ws.close(1000, "Server shutting down");
         } catch (error) {
           this.log(
-            "[WebSocket] Socket already destroyed during shutdown:",
+            "[WebSocket] Failed to close connection during shutdown:",
             error,
           );
         }
-      });
+      }
 
       this.clients.clear();
-      this.server.close();
+      await this.server.stop();
+      this.server = null;
     }
   }
 
@@ -358,13 +177,19 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
    * Silently ignores unknown socket IDs and write errors.
    */
   public send(socketId: string, data: unknown) {
-    const managed = this.clients.get(socketId);
-    if (managed) {
+    const client = this.clients.get(socketId);
+    if (client) {
       try {
-        const frame = this.encodeFrame(JSON.stringify(data));
-        managed.socket.write(frame);
+        const message = JSON.stringify(data);
+        client.ws.send(message).catch((error: Error) => {
+          this.log(`[WebSocket] Failed to send to ${socketId}:`, error);
+          this.emit(
+            "error",
+            error instanceof Error ? error : new Error(String(error)),
+          );
+        });
       } catch (error) {
-        this.log(`[WebSocket] Failed to send to ${socketId}:`, error);
+        this.log(`[WebSocket] Failed to serialize message:`, error);
         this.emit(
           "error",
           error instanceof Error ? error : new Error(String(error)),
@@ -375,181 +200,30 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
 
   /**
    * Broadcast data to all connected clients.
-   * Wraps each write in try/catch so a single dead socket doesn't skip remaining clients.
+   * Wraps each send in try/catch so a single failed send doesn't skip remaining clients.
    */
   public broadcast(data: unknown, excludeId?: string) {
-    const frame = this.encodeFrame(JSON.stringify(data));
-    this.clients.forEach((managed, id) => {
-      if (id !== excludeId) {
-        try {
-          managed.socket.write(frame);
-        } catch (error) {
-          this.log(`[WebSocket] Failed to broadcast to ${id}:`, error);
-          // Don't abort -- continue sending to remaining clients
-        }
-      }
-    });
-  }
-
-  /** Returns the number of currently connected clients. */
-  public get clientCount(): number {
-    return this.clients.size;
-  }
-
-  // --- Private Helpers ---
-
-  private handleHandshake(managed: ManagedSocket, header: string) {
-    this.log("[WebSocket] Handshake request header:", JSON.stringify(header));
-    const keyMatch = header.match(/Sec-WebSocket-Key: (.+)/);
-    if (!keyMatch) {
-      console.error("[WebSocket] Handshake failed: No Sec-WebSocket-Key found");
-      managed.socket.destroy();
-      return;
-    }
-
-    // Validate Sec-WebSocket-Version (RFC 6455 Section 4.2.1)
-    const versionMatch = header.match(/Sec-WebSocket-Version: (\d+)/);
-    if (versionMatch && versionMatch[1] !== "13") {
-      console.error(
-        `[WebSocket] Unsupported WebSocket version: ${versionMatch[1]}`,
-      );
-      managed.socket.destroy();
-      return;
-    }
-
-    const key = keyMatch[1].trim();
-    this.log("[WebSocket] Client Key:", key);
-
     try {
-      const acceptKey = this.generateAcceptKey(key);
-      this.log("[WebSocket] Generated Accept Key:", acceptKey);
-
-      const response = [
-        "HTTP/1.1 101 Switching Protocols",
-        "Upgrade: websocket",
-        "Connection: Upgrade",
-        `Sec-WebSocket-Accept: ${acceptKey}`,
-        "\r\n",
-      ].join("\r\n");
-
-      this.log(
-        "[WebSocket] Sending Handshake Response:",
-        JSON.stringify(response),
-      );
-      managed.socket.write(response);
-
-      // Assign cryptographically random ID and store
-      managed.id = generateId();
-      this.clients.set(managed.id, managed);
-      this.emit("connection", managed.id);
+      const message = JSON.stringify(data);
+      this.clients.forEach((client, id) => {
+        if (id !== excludeId) {
+          client.ws.send(message).catch((error: Error) => {
+            this.log(`[WebSocket] Failed to broadcast to ${id}:`, error);
+            // Don't abort -- continue sending to remaining clients
+          });
+        }
+      });
     } catch (error) {
-      console.error("[WebSocket] Handshake error:", error);
-      managed.socket.destroy();
-    }
-  }
-
-  private generateAcceptKey(key: string): string {
-    const input = key + GUID;
-    const hash = sha1(input);
-    this.log(`[WebSocket] SHA1 Input: ${input}`);
-    this.log(`[WebSocket] SHA1 Hash (hex): ${hash}`);
-    return Buffer.from(hash, "hex").toString("base64");
-  }
-
-  private decodeFrame(buffer: Buffer): DecodedFrame | null {
-    // Need at least 2 bytes for the header
-    if (buffer.length < 2) return null;
-
-    const firstByte = buffer[0];
-    const opcode = firstByte & 0x0f;
-
-    const secondByte = buffer[1];
-    const isMasked = (secondByte & 0x80) !== 0;
-    let payloadLength = secondByte & 0x7f;
-    let headerLength = 2;
-
-    if (payloadLength === 126) {
-      if (buffer.length < 4) return null; // Need 2 more bytes for extended length
-      payloadLength = buffer.readUInt16BE(2);
-      headerLength = 4;
-    } else if (payloadLength === 127) {
-      if (buffer.length < 10) return null; // Need 8 more bytes for extended length
-      // Read 64-bit length. For safety, only use the lower 32 bits.
-      const highBits = buffer.readUInt32BE(2);
-      if (highBits > 0) {
-        throw new Error("Frame payload too large (exceeds 4 GB)");
-      }
-      payloadLength = buffer.readUInt32BE(6);
-      headerLength = 10;
-    }
-
-    // Enforce max frame size to prevent memory exhaustion attacks
-    if (payloadLength > this.maxFrameSize) {
-      throw new Error(
-        `Frame payload (${payloadLength} bytes) exceeds maximum allowed size (${this.maxFrameSize} bytes)`,
-      );
-    }
-
-    const maskLength = isMasked ? 4 : 0;
-    const totalFrameLength = headerLength + maskLength + payloadLength;
-
-    // Check if we have the complete frame
-    if (buffer.length < totalFrameLength) return null;
-
-    let payload: Buffer;
-    if (isMasked) {
-      const mask = buffer.subarray(headerLength, headerLength + 4);
-      const maskedPayload = buffer.subarray(
-        headerLength + 4,
-        headerLength + 4 + payloadLength,
-      );
-      payload = Buffer.alloc(payloadLength);
-      for (let i = 0; i < payloadLength; i++) {
-        payload[i] = maskedPayload[i] ^ mask[i % 4];
-      }
-    } else {
-      payload = Buffer.from(
-        buffer.subarray(headerLength, headerLength + payloadLength),
+      this.log(`[WebSocket] Failed to serialize broadcast message:`, error);
+      this.emit(
+        "error",
+        error instanceof Error ? error : new Error(String(error)),
       );
     }
-
-    return { opcode, payload, bytesConsumed: totalFrameLength };
-  }
-
-  private encodeFrame(data: string): Buffer {
-    // Server -> Client frames are NOT masked (text frame)
-    return this.buildFrame(OPCODE.TEXT, Buffer.from(data));
-  }
-
-  private encodeControlFrame(opcode: number, payload: Buffer): Buffer {
-    return this.buildFrame(opcode, payload);
   }
 
-  private buildFrame(opcode: number, payload: Buffer): Buffer {
-    let headerLength = 2;
-
-    if (payload.length > 65535) {
-      headerLength = 10; // 2 header + 8 length
-    } else if (payload.length > 125) {
-      headerLength = 4; // 2 header + 2 length
-    }
-
-    const frame = Buffer.alloc(headerLength + payload.length);
-    frame[0] = 0x80 | opcode; // FIN bit set + opcode
-
-    if (payload.length > 65535) {
-      frame[1] = 127;
-      // Write 64-bit integer (max safe integer in JS is 2^53, so high 32 bits are 0)
-      frame.writeUInt32BE(0, 2);
-      frame.writeUInt32BE(payload.length, 6);
-    } else if (payload.length > 125) {
-      frame[1] = 126;
-      frame.writeUInt16BE(payload.length, 2);
-    } else {
-      frame[1] = payload.length;
-    }
-
-    payload.copy(frame, headerLength);
-    return frame;
+  /** Returns the number of currently connected clients. */
+  public get clientCount(): number {
+    return this.clients.size;
   }
 }