modd-network 1.0.3 → 1.0.6

package/dist/modd-engine.d.ts

@@ -97,7 +97,7 @@ export interface Game {
     processInput(input: any): void;
 }
 declare function createStateSync(options?: StateSyncConfig): GameInternal;
-export declare function connect(appId: string, room: string, options?: GameConnectOptions): Promise<Game>;
+export declare function connect(room: string, options?: GameConnectOptions): Promise<Game>;
 export declare function rapierAdapter(body: any): PhysicsAdapter;
 export declare function generic2DAdapter(getBody: () => any, setBody: (state: any) => void): PhysicsAdapter;
 interface InitOptions {

package/dist/modd-engine.js

@@ -489,7 +489,7 @@ function createStateSync(options = {}) {
 // ============================================
 // Main Connect Function
 // ============================================
-async function connect(appId, room, options = {}) {
+async function connect(room, options = {}) {
     // Create the game/state sync object
     const game = createStateSync(options.stateSync);
     // Set up onTick to process inputs
@@ -506,7 +506,7 @@ async function connect(appId, room, options = {}) {
         },
     };
     // Connect to network
-    const connection = await (0, modd_network_1.connect)(appId, room, gameOptions);
+    const connection = await (0, modd_network_1.connect)(room, gameOptions);
     game.setConnection(connection);
     // Return public interface (without setConnection)
     return game;

package/dist/modd-network.d.ts

@@ -42,6 +42,7 @@ export interface Connection {
 }
 export interface ConnectOptions {
     snapshot?: any;
+    appId?: string;
     user?: any;
     centralServiceUrl?: string;
     nodeUrl?: string;
@@ -69,5 +70,5 @@ export interface DecodedMessage {
 }
 export declare function encodeSyncHash(roomId: string, hash: string, seq: number, frame: number): Uint8Array;
 export declare function decodeBinaryMessage(buffer: ArrayBuffer): DecodedMessage | null;
-export declare function connect(appId: string, roomId: string, options?: ConnectOptions): Promise<Connection>;
+export declare function connect(roomId: string, options?: ConnectOptions): Promise<Connection>;
 export declare const modd: typeof connect;

package/dist/modd-network.js

@@ -253,7 +253,7 @@ async function toArrayBuffer(data) {
         return await data.arrayBuffer();
     return new Uint8Array(data).buffer;
 }
-async function connect(appId, roomId, options = {}) {
+async function connect(roomId, options = {}) {
     const initialSnapshot = options.snapshot || {};
     const user = options.user || null;
     const onConnect = options.onConnect || (() => { });
@@ -262,6 +262,7 @@ async function connect(appId, roomId, options = {}) {
     const onMessage = options.onMessage || (() => { });
     const onTick = options.onTick || null;
     const getStateHash = options.getStateHash || null;
+    const appId = options.appId || 'test-app';
     const centralServiceUrl = options.centralServiceUrl || (typeof window !== 'undefined' && (window.location.hostname === 'localhost' || window.location.hostname === '127.0.0.1')
         ? 'http://localhost:9001'
         : 'https://nodes.modd.io');
@@ -285,24 +286,29 @@ async function connect(appId, roomId, options = {}) {
     let lastSyncFrame = 0;
     let currentFrame = 0;
     let myClientId = null;
-    // Process events to auto-register clientIds from join/leave events
+    // Process events to auto-register clientIds from join/leave/disconnect/reconnect events
     // This is CRITICAL for binary TICK decoding - the hash lookup needs clientIds registered
     function processEventsForClientIds(events) {
         for (const event of events) {
             const data = event.data || {};
             const eventType = data.type || event.type;
-            if (eventType === 'join') {
+            if (eventType === 'join' || eventType === 'reconnect') {
+                // Register clientId for new joins and reconnections
                 const clientId = data.clientId || event.clientId;
                 if (clientId) {
                     registerClientId(clientId);
                 }
             }
             else if (eventType === 'leave') {
+                // Only unregister on permanent leave (not disconnect)
+                // Disconnected members may reconnect with a new clientId
                 const clientId = data.clientId || event.clientId;
                 if (clientId) {
                     unregisterClientId(clientId);
                 }
             }
+            // Note: 'disconnect' events do NOT unregister the clientId
+            // The member is still part of the room, just temporarily offline
         }
     }
     try {
@@ -378,11 +384,14 @@ async function connect(appId, roomId, options = {}) {
                     }
                 },
                 leaveRoom() {
-                    if (connected && user && ws) {
-                        const msg = JSON.stringify({ type: 'SEND_INPUT', payload: { roomId, data: { type: 'leave', user } } });
+                    if (connected && ws) {
+                        // Send proper LEAVE_ROOM message to permanently exit the room
+                        // This broadcasts a "leave" event to other clients
+                        const msg = JSON.stringify({ type: 'LEAVE_ROOM', payload: { roomId } });
                         bytesOut += msg.length;
                         ws.send(msg);
                     }
+                    // Close the WebSocket after sending leave message
                     if (ws)
                         ws.close();
                 },
@@ -461,7 +470,7 @@ async function connect(appId, roomId, options = {}) {
                 }
                 bytesIn += buffer.byteLength;
                 const msg = decodeBinaryMessage(buffer);
-                console.log("decoded msg: ", msg);
+                // console.log("decoded msg: ", msg);
                 if (!msg)
                     return;
                 switch (msg.type) {
@@ -528,6 +537,9 @@ async function connect(appId, roomId, options = {}) {
                             const maxSeq = Math.max(...events.map(e => e.seq || 0));
                             if (maxSeq > lastSyncSeq)
                                 lastSyncSeq = maxSeq;
+                            // CRITICAL: Mark all INITIAL_STATE events as delivered
+                            // to prevent duplicate processing when same events arrive via TICK
+                            events.forEach(e => deliveredSeqs.add(e.seq));
                         }
                         // Auto-register clientIds from join events in history
                         if (events && events.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modd-network",
-  "version": "1.0.3",
+  "version": "1.0.6",
   "description": "SDK for connecting to mesh network for multiplayer applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/README.md

@@ -1,40 +0,0 @@
-# MODD Network SDK
-
-The official SDK for connecting to the MODD mesh network for multiplayer applications.
-
-## Installation
-
-```bash
-npm install modd-network
-```
-
-## Usage
-
-```typescript
-import { modd } from 'modd-network';
-
-// Connect to a room
-const connection = await modd('my-room-id', {
-  appId: 'your-app-id',
-  onConnect: (snapshot, inputs) => {
-    console.log('Connected with snapshot:', snapshot);
-  },
-  onTick: (frame, inputs) => {
-    console.log('Tick:', frame, inputs);
-  },
-  onDisconnect: () => {
-    console.log('Disconnected');
-  }
-});
-
-// Send input
-connection.send({ x: 10, y: 20 });
-```
-
-## Features
-
-- Room creation and joining
-- Real-time input synchronization (Binary protocol)
-- Snapshot state management
-- Game engine utilities (Physics sync, Delta compression)
-- Mesh network connectivity (Browser & Node.js)