@couch-kit/host 0.4.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@couch-kit/host",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "React Native host for local multiplayer party games on Android TV — WebSocket server, state management, and static file serving",
   "license": "MIT",
   "repository": {
@@ -22,6 +22,14 @@
   "main": "src/index.tsx",
   "react-native": "src/index.tsx",
   "source": "src/index.tsx",
+  "exports": {
+    ".": {
+      "react-native": "./src/index.tsx",
+      "types": "./src/index.tsx",
+      "default": "./src/index.tsx"
+    }
+  },
+  "sideEffects": false,
   "files": [
     "src",
     "lib",
@@ -43,12 +51,12 @@
     "clean": "del-cli lib"
   },
   "dependencies": {
-    "@couch-kit/core": "0.3.0",
+    "@couch-kit/core": "0.3.1",
+    "buffer": "^6.0.3",
     "js-sha1": "^0.7.0",
     "react-native-fs": "^2.20.0",
     "react-native-network-info": "^5.2.1",
     "react-native-nitro-http-server": "^1.5.4",
-    "react-native-nitro-modules": "^0.33.2",
     "react-native-tcp-socket": "^6.0.6"
   },
   "devDependencies": {
@@ -61,6 +69,7 @@
   },
   "peerDependencies": {
     "react": "*",
-    "react-native": "*"
+    "react-native": "*",
+    "react-native-nitro-modules": ">=0.33.0"
   }
 }

package/src/event-emitter.ts

@@ -16,12 +16,12 @@
  * ```
  */
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+/* eslint-disable @typescript-eslint/no-explicit-any */
 export class EventEmitter<
   EventMap extends Record<string, any[]> = Record<string, any[]>,
 > {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   private listeners: Map<string, Array<(...args: any[]) => void>> = new Map();
+  /* eslint-enable @typescript-eslint/no-explicit-any */
 
   on<K extends string & keyof EventMap>(
     event: K,

package/src/provider.tsx

@@ -5,6 +5,7 @@ import React, {
   useMemo,
   useReducer,
   useRef,
+  useCallback,
 } from "react";
 import { GameWebSocketServer } from "./websocket";
 import { useStaticServer } from "./server";
@@ -13,6 +14,7 @@ import {
   InternalActionTypes,
   DEFAULT_HTTP_PORT,
   DEFAULT_WS_PORT_OFFSET,
+  createGameReducer,
   type IGameState,
   type IAction,
   type InternalAction,
@@ -21,7 +23,7 @@ import {
 
 export interface GameHostConfig<S extends IGameState, A extends IAction> {
   initialState: S;
-  reducer: (state: S, action: A | InternalAction<S>) => S;
+  reducer: (state: S, action: A) => S;
   port?: number; // Static server port (default 8080)
   wsPort?: number; // WebSocket port (default: HTTP port + 2, i.e. 8082)
   devMode?: boolean;
@@ -38,7 +40,7 @@ export interface GameHostConfig<S extends IGameState, A extends IAction> {
 
 interface GameHostContextValue<S extends IGameState, A extends IAction> {
   state: S;
-  dispatch: (action: A | InternalAction<S>) => void;
+  dispatch: (action: A) => void;
   serverUrl: string | null;
   serverError: Error | null;
 }
@@ -92,7 +94,12 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
   children: React.ReactNode;
   config: GameHostConfig<S, A>;
 }) {
-  const [state, dispatch] = useReducer(config.reducer, config.initialState);
+  // Wrap the user's reducer with createGameReducer to handle internal actions
+  // (HYDRATE, PLAYER_JOINED, PLAYER_LEFT) automatically.
+  const [state, dispatch] = useReducer(
+    createGameReducer(config.reducer),
+    config.initialState,
+  );
 
   // Keep a ref to state so we can access it inside callbacks/effects that don't depend on it
   const stateRef = useRef(state);
@@ -262,22 +269,40 @@ export function GameHostProvider<S extends IGameState, A extends IAction>({
     return () => {
       server.stop();
     };
-    // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []); // Run once on mount
 
-  // 3. Broadcast State Updates
-  // Whenever React state changes, send it to all clients that have been welcomed
-  useEffect(() => {
+  // 3. Throttled State Broadcasts (~30fps)
+  // Batches rapid state changes so at most one broadcast is sent per ~33ms frame,
+  // reducing serialization overhead and network traffic for fast-updating games.
+  const broadcastPending = useRef(false);
+  const broadcastTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  const broadcastState = useCallback(() => {
     if (wsServer.current) {
       wsServer.current.broadcast({
         type: MessageTypes.STATE_UPDATE,
         payload: {
-          newState: state,
+          newState: stateRef.current,
           timestamp: Date.now(),
         },
       });
     }
-  }, [state]);
+    broadcastPending.current = false;
+  }, []);
+
+  useEffect(() => {
+    if (!broadcastPending.current) {
+      broadcastPending.current = true;
+      broadcastTimer.current = setTimeout(broadcastState, 33); // ~30fps
+    }
+
+    return () => {
+      if (broadcastTimer.current) {
+        clearTimeout(broadcastTimer.current);
+        broadcastTimer.current = null;
+      }
+    };
+  }, [state, broadcastState]);
 
   // Memoize context value to prevent unnecessary re-renders of consumers
   // that only use stable references like dispatch

package/src/websocket.ts

@@ -50,6 +50,43 @@ const OPCODE = {
 // Simple WebSocket Frame Parser/Builder
 const GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
 
+/** Initial capacity for per-client receive buffers. */
+const INITIAL_BUFFER_CAPACITY = 4096;
+
+/**
+ * Append data to a managed socket's buffer, growing capacity geometrically
+ * to avoid re-allocation on every TCP data event.
+ */
+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.
+ */
+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;
+}
+
 interface DecodedFrame {
   opcode: number;
   payload: Buffer;
@@ -64,6 +101,8 @@ interface ManagedSocket {
   id: string;
   isHandshakeComplete: boolean;
   buffer: Buffer;
+  /** Number of valid bytes currently in `buffer` (may be less than buffer.length). */
+  bufferLength: number;
   lastPong: number;
 }
 
@@ -105,7 +144,8 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
         socket: rawSocket,
         id: "",
         isHandshakeComplete: false,
-        buffer: Buffer.alloc(0),
+        buffer: Buffer.alloc(INITIAL_BUFFER_CAPACITY),
+        bufferLength: 0,
         lastPong: Date.now(),
       };
 
@@ -113,24 +153,26 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
         this.log(
           `[WebSocket] Received data chunk: ${typeof data === "string" ? data.length : data.length} bytes`,
         );
-        // Concatenate new data
-        managed.buffer = Buffer.concat([
-          managed.buffer,
-          typeof data === "string" ? Buffer.from(data) : data,
-        ]);
+        // 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");
+          const header = managed.buffer.toString(
+            "utf8",
+            0,
+            managed.bufferLength,
+          );
           const endOfHeader = header.indexOf("\r\n\r\n");
           if (endOfHeader !== -1) {
             this.handleHandshake(managed, header);
-            // Retain any bytes after the handshake (could be the first WS frame)
+            // Compact buffer past the handshake header
             const headerByteLength = Buffer.byteLength(
               header.substring(0, endOfHeader + 4),
               "utf8",
             );
-            managed.buffer = managed.buffer.slice(headerByteLength);
+            compactBuffer(managed, headerByteLength);
             managed.isHandshakeComplete = true;
             // Fall through to process any remaining frames below
           } else {
@@ -139,9 +181,7 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
         }
 
         // Process all complete frames in the buffer
-        this.processFrames(managed, (remaining) => {
-          managed.buffer = remaining;
-        });
+        this.processFrames(managed);
       });
 
       rawSocket.on("error", (error: Error) => {
@@ -204,16 +244,15 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
     }, this.keepaliveInterval);
   }
 
-  private processFrames(
-    managed: ManagedSocket,
-    setBuffer: (b: Buffer) => void,
-  ) {
-    let { buffer } = managed;
+  private processFrames(managed: ManagedSocket) {
+    let offset = 0;
 
-    while (buffer.length > 0) {
+    while (offset < managed.bufferLength) {
+      // Create a view of the unconsumed portion for decoding
+      const view = managed.buffer.subarray(offset, managed.bufferLength);
       let frame: DecodedFrame | null;
       try {
-        frame = this.decodeFrame(buffer);
+        frame = this.decodeFrame(view);
       } catch (error) {
         // Frame too large or malformed -- disconnect the client
         this.log(`[WebSocket] Frame error from ${managed.id}:`, error);
@@ -226,12 +265,12 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
       }
 
       if (!frame) {
-        // Incomplete frame -- keep buffer, wait for more data
+        // Incomplete frame -- keep remaining bytes, wait for more data
         break;
       }
 
-      // Advance buffer past the consumed frame
-      buffer = buffer.slice(frame.bytesConsumed);
+      // Advance past the consumed frame
+      offset += frame.bytesConsumed;
 
       // Handle frame by opcode
       switch (frame.opcode) {
@@ -302,7 +341,8 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
       if (managed.socket.destroyed) break;
     }
 
-    setBuffer(buffer);
+    // Compact buffer: shift unconsumed bytes to the front
+    compactBuffer(managed, offset);
   }
 
   /**
@@ -486,8 +526,8 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
 
     let payload: Buffer;
     if (isMasked) {
-      const mask = buffer.slice(headerLength, headerLength + 4);
-      const maskedPayload = buffer.slice(
+      const mask = buffer.subarray(headerLength, headerLength + 4);
+      const maskedPayload = buffer.subarray(
         headerLength + 4,
         headerLength + 4 + payloadLength,
       );
@@ -497,7 +537,7 @@ export class GameWebSocketServer extends EventEmitter<WebSocketServerEvents> {
       }
     } else {
       payload = Buffer.from(
-        buffer.slice(headerLength, headerLength + payloadLength),
+        buffer.subarray(headerLength, headerLength + payloadLength),
       );
     }