@couch-kit/host 1.3.1 → 1.5.0

package/lib/provider.d.ts

@@ -9,6 +9,8 @@ export interface GameHostConfig<S extends IGameState, A extends IAction> {
     devServerUrl?: string;
     staticDir?: string;
     debug?: boolean;
+    /** Timeout (ms) before a disconnected player is permanently removed (default: 5 minutes). */
+    disconnectTimeout?: number;
     /** Called when a player successfully joins. */
     onPlayerJoined?: (playerId: string, name: string) => void;
     /** Called when a player disconnects. */

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,EAUL,KAAK,UAAU,EACf,KAAK,OAAO,EAGb,MAAM,iBAAiB,CAAC;AAQzB,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,6FAA6F;IAC7F,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,+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,qBAmaA;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.1",
+  "version": "1.5.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.6.0",
     "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/provider.tsx

@@ -14,8 +14,10 @@ import {
   InternalActionTypes,
   DEFAULT_HTTP_PORT,
   DEFAULT_WS_PORT_OFFSET,
+  DEFAULT_DISCONNECT_TIMEOUT,
   createGameReducer,
   derivePlayerId,
+  derivePlayerIdLegacy,
   isValidSecret,
   type IGameState,
   type IAction,
@@ -23,6 +25,12 @@ import {
   type ClientMessage,
 } from "@couch-kit/core";
 
+/** Maximum actions per rate-limit window. */
+const RATE_LIMIT_MAX = 60;
+
+/** Rate-limit window duration (ms). */
+const RATE_LIMIT_WINDOW = 1000;
+
 export interface GameHostConfig<S extends IGameState, A extends IAction> {
   initialState: S;
   reducer: (state: S, action: A) => S;
@@ -32,6 +40,8 @@ export interface GameHostConfig<S extends IGameState, A extends IAction> {
   devServerUrl?: string;
   staticDir?: string; // Override the default www directory path (required on Android)
   debug?: boolean;
+  /** Timeout (ms) before a disconnected player is permanently removed (default: 5 minutes). */
+  disconnectTimeout?: number;
   /** Called when a player successfully joins. */
   onPlayerJoined?: (playerId: string, name: string) => void;
   /** Called when a player disconnects. */
@@ -125,23 +135,36 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
     stateRef.current = state;
   }, [state]);
 
-  // Send WELCOME messages after state has settled (post-render).
+  // Send WELCOME/RECONNECTED messages after state has settled (post-render).
   // This guarantees the joining player is included in the state snapshot.
   useEffect(() => {
     if (pendingWelcome.current.size === 0) return;
     if (!wsServer.current) return;
 
     const server = wsServer.current;
-    for (const [socketId, playerId] of pendingWelcome.current) {
+    for (const [
+      socketId,
+      { playerId, isReconnect },
+    ] of pendingWelcome.current) {
       welcomedClients.current.add(socketId);
-      server.send(socketId, {
-        type: MessageTypes.WELCOME,
-        payload: {
-          playerId,
-          state,
-          serverTime: Date.now(),
-        },
-      });
+      if (isReconnect) {
+        server.send(socketId, {
+          type: MessageTypes.RECONNECTED,
+          payload: {
+            playerId,
+            state,
+          },
+        });
+      } else {
+        server.send(socketId, {
+          type: MessageTypes.WELCOME,
+          payload: {
+            playerId,
+            state,
+            serverTime: Date.now(),
+          },
+        });
+      }
     }
     pendingWelcome.current.clear();
   }, [state]);
@@ -178,14 +201,36 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
   // Track socket IDs that have received their WELCOME message
   const welcomedClients = useRef<Set<string>>(new Set());
 
-  // Track socket IDs that need a WELCOME message after state settles
-  const pendingWelcome = useRef<Map<string, string>>(new Map()); // socketId -> playerId
+  // Track socket IDs that need a WELCOME/RECONNECTED message after state settles
+  const pendingWelcome = useRef<
+    Map<string, { playerId: string; isReconnect: boolean }>
+  >(new Map());
+
+  // Cache: socketId -> playerId (avoids async derivation in hot paths)
+  const socketIdToPlayerId = useRef<Map<string, string>>(new Map());
+
+  // Track which players have finished loading assets
+  const assetsLoaded = useRef<Map<string, boolean>>(new Map());
+
+  // Queue of actions dispatched since last broadcast (for STATE_UPDATE.action)
+  const actionQueue = useRef<unknown[]>([]);
+
+  // Rate limiting: track action count per socket
+  const rateLimits = useRef<
+    Map<string, { count: number; windowStart: number }>
+  >(new Map());
 
   useEffect(() => {
     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) => {
@@ -234,39 +279,69 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
             return;
           }
 
-          const playerId = derivePlayerId(secret);
-
-          // Update session maps
-          sessions.current.set(secret, socketId);
-          reverseMap.current.set(socketId, secret);
-
-          // Cancel any pending cleanup timer for this player
-          const existingTimer = cleanupTimers.current.get(playerId);
-          if (existingTimer) {
-            clearTimeout(existingTimer);
-            cleanupTimers.current.delete(playerId);
-          }
-
-          // Check if this is a returning player
-          const existingPlayer = stateRef.current.players[playerId];
-          if (existingPlayer) {
-            // Reconnection — restore existing player
-            dispatch({
-              type: InternalActionTypes.PLAYER_RECONNECTED,
-              payload: { playerId },
-            } as InternalAction<S>);
-          } else {
-            // New player
-            dispatch({
-              type: InternalActionTypes.PLAYER_JOINED,
-              payload: { id: playerId, ...payload },
-            } as InternalAction<S>);
-          }
-
-          // Queue WELCOME
-          pendingWelcome.current.set(socketId, playerId);
-
-          configRef.current.onPlayerJoined?.(playerId, payload.name);
+          // Async dual-derivation: try SHA-256 first, fall back to legacy
+          derivePlayerId(secret).then((hashedId) => {
+            let playerId = hashedId;
+
+            // Migration: if a player exists under the legacy ID, use that instead
+            const legacyId = derivePlayerIdLegacy(secret);
+            if (
+              !stateRef.current.players[playerId] &&
+              stateRef.current.players[legacyId]
+            ) {
+              playerId = legacyId;
+            }
+
+            // Cache the resolved playerId for this socket
+            socketIdToPlayerId.current.set(socketId, playerId);
+
+            // Update session maps
+            sessions.current.set(secret, socketId);
+            reverseMap.current.set(socketId, secret);
+
+            // Cancel any pending cleanup timer for this player
+            const existingTimer = cleanupTimers.current.get(playerId);
+            if (existingTimer) {
+              clearTimeout(existingTimer);
+              cleanupTimers.current.delete(playerId);
+            }
+
+            // Check if this is a returning player
+            const existingPlayer = stateRef.current.players[playerId];
+            if (existingPlayer) {
+              // Reconnection — restore existing player
+              dispatch({
+                type: InternalActionTypes.PLAYER_RECONNECTED,
+                payload: { playerId },
+              } as InternalAction<S>);
+
+              // Reset assets loaded status on reconnect
+              assetsLoaded.current.set(playerId, false);
+
+              // Queue RECONNECTED message
+              pendingWelcome.current.set(socketId, {
+                playerId,
+                isReconnect: true,
+              });
+            } else {
+              // New player
+              dispatch({
+                type: InternalActionTypes.PLAYER_JOINED,
+                payload: { id: playerId, ...payload },
+              } as InternalAction<S>);
+
+              // Initialize assets loaded status
+              assetsLoaded.current.set(playerId, false);
+
+              // Queue WELCOME message
+              pendingWelcome.current.set(socketId, {
+                playerId,
+                isReconnect: false,
+              });
+            }
+
+            configRef.current.onPlayerJoined?.(playerId, payload.name);
+          });
           break;
         }
 
@@ -296,12 +371,32 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
             });
             return;
           }
-          // Resolve playerId from socketId
-          const actionSecret = reverseMap.current.get(socketId);
-          const resolvedPlayerId = actionSecret
-            ? derivePlayerId(actionSecret)
-            : undefined;
+
+          // Rate limiting
+          const now = Date.now();
+          let rateInfo = rateLimits.current.get(socketId);
+          if (!rateInfo || now - rateInfo.windowStart > RATE_LIMIT_WINDOW) {
+            rateInfo = { count: 0, windowStart: now };
+            rateLimits.current.set(socketId, rateInfo);
+          }
+          rateInfo.count++;
+          if (rateInfo.count > RATE_LIMIT_MAX) {
+            if (configRef.current.debug)
+              console.warn(`[GameHost] Rate limited ${socketId}`);
+            server.send(socketId, {
+              type: MessageTypes.ERROR,
+              payload: {
+                code: "RATE_LIMITED",
+                message: "Too many actions, slow down",
+              },
+            });
+            return;
+          }
+
+          // Use cached playerId (populated at JOIN time)
+          const resolvedPlayerId = socketIdToPlayerId.current.get(socketId);
           dispatch({ ...actionPayload, playerId: resolvedPlayerId });
+          actionQueue.current.push(actionPayload);
           break;
         }
 
@@ -315,6 +410,16 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
             },
           });
           break;
+
+        case MessageTypes.ASSETS_LOADED: {
+          const loadedPlayerId = socketIdToPlayerId.current.get(socketId);
+          if (loadedPlayerId) {
+            assetsLoaded.current.set(loadedPlayerId, true);
+            if (configRef.current.debug)
+              console.log(`[GameHost] Assets loaded for ${loadedPlayerId}`);
+          }
+          break;
+        }
       }
     });
 
@@ -324,13 +429,21 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
 
       welcomedClients.current.delete(socketId);
 
-      // Resolve socketId -> secret -> playerId
+      // Use cached playerId
+      const playerId = socketIdToPlayerId.current.get(socketId);
+      socketIdToPlayerId.current.delete(socketId);
+
+      // Clean up reverse map
       const secret = reverseMap.current.get(socketId);
       reverseMap.current.delete(socketId);
 
-      if (!secret) return; // Unknown socket, nothing to do
+      // Clean up rate limits
+      rateLimits.current.delete(socketId);
+
+      if (!playerId || !secret) return; // Unknown socket, nothing to do
 
-      const playerId = derivePlayerId(secret);
+      // Clean up assets loaded tracking
+      assetsLoaded.current.delete(playerId);
 
       // RACE GUARD: Only mark as left if this socket is still the active one for this secret
       if (sessions.current.get(secret) !== socketId) {
@@ -346,18 +459,17 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
 
       configRef.current.onPlayerLeft?.(playerId);
 
-      // Start stale player cleanup timer (5 minutes default)
-      const timer = setTimeout(
-        () => {
-          cleanupTimers.current.delete(playerId);
-          sessions.current.delete(secret);
-          dispatch({
-            type: InternalActionTypes.PLAYER_REMOVED,
-            payload: { playerId },
-          } as InternalAction<S>);
-        },
-        5 * 60 * 1000,
-      );
+      // Start stale player cleanup timer
+      const timeout =
+        configRef.current.disconnectTimeout ?? DEFAULT_DISCONNECT_TIMEOUT;
+      const timer = setTimeout(() => {
+        cleanupTimers.current.delete(playerId);
+        sessions.current.delete(secret);
+        dispatch({
+          type: InternalActionTypes.PLAYER_REMOVED,
+          payload: { playerId },
+        } as InternalAction<S>);
+      }, timeout);
       cleanupTimers.current.set(playerId, timer);
     });
 
@@ -383,11 +495,18 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
 
   const broadcastState = useCallback(() => {
     if (wsServer.current) {
+      const actions = actionQueue.current;
+      actionQueue.current = [];
       wsServer.current.broadcast({
         type: MessageTypes.STATE_UPDATE,
         payload: {
           newState: stateRef.current,
           timestamp: Date.now(),
+          ...(actions.length === 1
+            ? { action: actions[0] }
+            : actions.length > 1
+              ? { action: actions }
+              : {}),
         },
       });
     }

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;
   }
 }

package/lib/buffer-utils.d.ts

@@ -1,27 +0,0 @@
-/**
- * Buffer management utilities for WebSocket per-client receive buffers.
- * Extracted into a standalone module so they can be tested without
- * react-native dependencies.
- */
-import { Buffer } from "buffer";
-import type { TcpSocketInstance } from "./declarations";
-export interface ManagedSocket {
-    socket: TcpSocketInstance;
-    id: string;
-    isHandshakeComplete: boolean;
-    buffer: Buffer;
-    /** Number of valid bytes currently in `buffer` (may be less than buffer.length). */
-    bufferLength: number;
-    lastPong: number;
-}
-/**
- * Append data to a managed socket's buffer, growing capacity geometrically
- * to avoid re-allocation on every TCP data event.
- */
-export declare function appendToBuffer(managed: ManagedSocket, data: Buffer): void;
-/**
- * Compact the buffer by discarding consumed bytes from the front.
- * If all data has been consumed, reset the length to 0 without re-allocating.
- */
-export declare function compactBuffer(managed: ManagedSocket, consumed: number): void;
-//# sourceMappingURL=buffer-utils.d.ts.map

package/lib/buffer-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"buffer-utils.d.ts","sourceRoot":"","sources":["../src/buffer-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,mBAAmB,EAAE,OAAO,CAAC;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,oFAAoF;IACpF,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAazE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAS5E"}

package/src/buffer-utils.ts

@@ -1,53 +0,0 @@
-/**
- * Buffer management utilities for WebSocket per-client receive buffers.
- * Extracted into a standalone module so they can be tested without
- * react-native dependencies.
- */
-
-import { Buffer } from "buffer";
-import type { TcpSocketInstance } from "./declarations";
-
-// Internal type for a TCP socket with our added management properties.
-export interface ManagedSocket {
-  socket: TcpSocketInstance;
-  id: string;
-  isHandshakeComplete: boolean;
-  buffer: Buffer;
-  /** Number of valid bytes currently in `buffer` (may be less than buffer.length). */
-  bufferLength: number;
-  lastPong: number;
-}
-
-/**
- * Append data to a managed socket's buffer, growing capacity geometrically
- * to avoid re-allocation on every TCP data event.
- */
-export function appendToBuffer(managed: ManagedSocket, data: Buffer): void {
-  const needed = managed.bufferLength + data.length;
-
-  if (needed > managed.buffer.length) {
-    // Grow by at least 2x or to fit the new data, whichever is larger
-    const newCapacity = Math.max(managed.buffer.length * 2, needed);
-    const grown = Buffer.alloc(newCapacity);
-    managed.buffer.copy(grown, 0, 0, managed.bufferLength);
-    managed.buffer = grown;
-  }
-
-  data.copy(managed.buffer, managed.bufferLength);
-  managed.bufferLength = needed;
-}
-
-/**
- * Compact the buffer by discarding consumed bytes from the front.
- * If all data has been consumed, reset the length to 0 without re-allocating.
- */
-export function compactBuffer(managed: ManagedSocket, consumed: number): void {
-  const remaining = managed.bufferLength - consumed;
-  if (remaining <= 0) {
-    managed.bufferLength = 0;
-    return;
-  }
-  // Shift remaining bytes to the front of the existing buffer
-  managed.buffer.copy(managed.buffer, 0, consumed, managed.bufferLength);
-  managed.bufferLength = remaining;
-}

package/src/declarations.d.ts

@@ -1,25 +0,0 @@
-/**
- * Minimal type definition for the raw TCP socket provided by react-native-tcp-socket.
- * Covers only the API surface used by GameWebSocketServer.
- */
-
-import type { Buffer } from "buffer";
-
-export interface TcpSocketInstance {
-  write(data: string | Buffer): void;
-  destroy(): void;
-  on(event: "data", callback: (data: Buffer | string) => void): this;
-  on(event: "error", callback: (error: Error) => void): this;
-  on(event: "close", callback: (hadError: boolean) => void): this;
-  address():
-    | { address: string; family: string; port: number }
-    | Record<string, never>;
-  readonly destroyed: boolean;
-}
-
-declare module "react-native-nitro-http-server" {
-  export class StaticServer {
-    start(port: number, path: string, host?: string): Promise<void>;
-    stop(): void;
-  }
-}