modd-network 1.0.2 → 1.0.3

package/dist/modd-network.js

@@ -1,19 +1,14 @@
 "use strict";
-/**
- * MODD Network SDK
- * Pure network layer for real-time multiplayer applications
- * Works with any app type: games, chat, collaboration, etc.
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.modd = void 0;
+exports.modd = exports.unregisterPlayerId = exports.registerPlayerId = exports.hashPlayerId = void 0;
+exports.hashClientId = hashClientId;
+exports.registerClientId = registerClientId;
+exports.unregisterClientId = unregisterClientId;
+exports.encodeSyncHash = encodeSyncHash;
+exports.decodeBinaryMessage = decodeBinaryMessage;
 exports.connect = connect;
-const ws_1 = __importDefault(require("ws"));
-// ============================================
-// Binary Protocol
-// ============================================
+const state_codec_1 = require("./state-codec");
+// Binary Message Types (Must match node/src/binary-protocol.ts)
 const BinaryMessageType = {
     TICK: 0x01,
     INITIAL_STATE: 0x02,
@@ -22,128 +17,243 @@ const BinaryMessageType = {
     ERROR: 0x05,
     SNAPSHOT_UPDATE: 0x06,
     ROOM_LEFT: 0x07,
-    SYNC_HASH: 0x08
+    SYNC_HASH: 0x08,
+    CLIENT_LIST_UPDATE: 0x09
 };
+/**
+ * Hash a client ID to a 4-byte identifier (matches server-side hash)
+ * Uses FNV-1a hash for speed and consistency
+ */
+function hashClientId(clientId) {
+    let hash = 2166136261; // FNV offset basis
+    for (let i = 0; i < clientId.length; i++) {
+        hash ^= clientId.charCodeAt(i);
+        hash = Math.imul(hash, 16777619) >>> 0; // FNV prime, keep as 32-bit unsigned
+    }
+    return hash;
+}
+// Backwards compat alias
+exports.hashPlayerId = hashClientId;
+// Map clientHash -> clientId for decoding TICK messages
+const clientHashMap = new Map();
+/**
+ * Register a client ID so we can decode their hash in TICK messages
+ * Call this when a client joins (from the join event's clientId)
+ */
+function registerClientId(clientId) {
+    const hash = hashClientId(clientId);
+    clientHashMap.set(hash, clientId);
+}
+// Backwards compat alias
+exports.registerPlayerId = registerClientId;
+/**
+ * Unregister a client ID (call on leave)
+ */
+function unregisterClientId(clientId) {
+    const hash = hashClientId(clientId);
+    clientHashMap.delete(hash);
+}
+// Backwards compat alias
+exports.unregisterPlayerId = unregisterClientId;
+/**
+ * Look up client ID from hash
+ */
+function lookupClientHash(hash) {
+    return clientHashMap.get(hash);
+}
+// Encode sync hash
 function encodeSyncHash(roomId, hash, seq, frame) {
     const roomIdBytes = new TextEncoder().encode(roomId);
     const hashBytes = new TextEncoder().encode(hash);
-    const totalLen = 1 + 2 + roomIdBytes.length + 2 + hashBytes.length + 4 + 4;
-    const buffer = new ArrayBuffer(totalLen);
-    const view = new DataView(buffer);
-    const uint8 = new Uint8Array(buffer);
+    // 1 (type) + 2 (roomId len) + roomId + 2 (hash len) + hash + 4 (seq) + 4 (frame)
+    const buf = new Uint8Array(1 + 2 + roomIdBytes.length + 2 + hashBytes.length + 4 + 4);
+    const view = new DataView(buf.buffer);
     let offset = 0;
-    view.setUint8(offset, BinaryMessageType.SYNC_HASH);
-    offset += 1;
+    buf[offset++] = BinaryMessageType.SYNC_HASH;
     view.setUint16(offset, roomIdBytes.length, true);
     offset += 2;
-    uint8.set(roomIdBytes, offset);
+    buf.set(roomIdBytes, offset);
     offset += roomIdBytes.length;
     view.setUint16(offset, hashBytes.length, true);
     offset += 2;
-    uint8.set(hashBytes, offset);
+    buf.set(hashBytes, offset);
     offset += hashBytes.length;
     view.setUint32(offset, seq, true);
     offset += 4;
     view.setUint32(offset, frame, true);
-    return buffer;
+    return buf;
 }
 function decodeBinaryMessage(buffer) {
-    const view = new DataView(buffer);
     if (buffer.byteLength === 0)
         return null;
+    const view = new DataView(buffer);
     const type = view.getUint8(0);
-    switch (type) {
-        case BinaryMessageType.TICK: {
-            const frame = view.getUint32(1, true);
-            let inputs = [];
-            if (buffer.byteLength > 5) {
-                const inputCount = view.getUint16(5, true);
-                if (inputCount > 0) {
-                    const inputsJson = new TextDecoder().decode(buffer.slice(7));
-                    inputs = JSON.parse(inputsJson);
+    try {
+        switch (type) {
+            case BinaryMessageType.TICK: {
+                // Binary format: [type:1][frame:4][count:1][inputs...]
+                // Each input: [clientHash:4][seq:4][dataLen:2][data:dataLen]
+                // Data can be JSON (join/leave) or binary (game inputs)
+                const frame = view.getUint32(1, true);
+                let events = [];
+                if (buffer.byteLength > 5) {
+                    const inputCount = view.getUint8(5);
+                    let offset = 6;
+                    for (let i = 0; i < inputCount && offset < buffer.byteLength; i++) {
+                        const clientHash = view.getUint32(offset, true);
+                        offset += 4;
+                        const seq = view.getUint32(offset, true);
+                        offset += 4; // UInt32 to support >65535 events
+                        const dataLen = view.getUint16(offset, true);
+                        offset += 2;
+                        if (offset + dataLen > buffer.byteLength)
+                            break;
+                        const rawBytes = new Uint8Array(buffer, offset, dataLen);
+                        offset += dataLen;
+                        // Detect format: JSON starts with '{' (0x7B) or '[' (0x5B)
+                        let data;
+                        const firstByte = rawBytes[0];
+                        if (firstByte === 0x7B || firstByte === 0x5B) {
+                            // JSON format - decode for join/leave events
+                            try {
+                                const jsonStr = new TextDecoder().decode(rawBytes);
+                                data = JSON.parse(jsonStr);
+                            }
+                            catch {
+                                data = rawBytes;
+                            }
+                        }
+                        else {
+                            // Binary format - pass raw bytes to game layer
+                            data = rawBytes;
+                        }
+                        // Look up client ID from hash
+                        let clientId;
+                        if (typeof data === 'object' && !(data instanceof Uint8Array)) {
+                            // Auto-register clientId if present (e.g., join events)
+                            // This ensures hash lookups work for subsequent inputs
+                            if (data.clientId && !lookupClientHash(clientHash)) {
+                                registerClientId(data.clientId);
+                            }
+                            clientId = data.clientId || lookupClientHash(clientHash) || `hash_${clientHash.toString(16)}`;
+                        }
+                        else {
+                            clientId = lookupClientHash(clientHash) || `hash_${clientHash.toString(16)}`;
+                        }
+                        events.push({ seq, data, clientId, clientHash });
+                    }
                 }
+                return { type: 'TICK', frame, events };
             }
-            return { type: 'TICK', frame, inputs };
-        }
-        case BinaryMessageType.INITIAL_STATE: {
-            let offset = 1;
-            const frame = view.getUint32(offset, true);
-            offset += 4;
-            const roomIdLen = view.getUint16(offset, true);
-            offset += 2;
-            const roomId = new TextDecoder().decode(buffer.slice(offset, offset + roomIdLen));
-            offset += roomIdLen;
-            const snapshotLen = view.getUint32(offset, true);
-            offset += 4;
-            const snapshotJson = new TextDecoder().decode(buffer.slice(offset, offset + snapshotLen));
-            offset += snapshotLen;
-            const inputsLen = view.getUint32(offset, true);
-            offset += 4;
-            const inputsJson = new TextDecoder().decode(buffer.slice(offset, offset + inputsLen));
-            const { snapshot, snapshotHash } = JSON.parse(snapshotJson);
-            const inputs = JSON.parse(inputsJson);
-            return { type: 'INITIAL_STATE', roomId, frame, snapshot, snapshotHash, inputs };
-        }
-        case BinaryMessageType.ROOM_JOINED: {
-            const roomIdLen = view.getUint16(1, true);
-            const roomId = new TextDecoder().decode(buffer.slice(3, 3 + roomIdLen));
-            return { type: 'ROOM_JOINED', roomId };
-        }
-        case BinaryMessageType.ROOM_CREATED: {
-            let offset = 1;
-            const roomIdLen = view.getUint16(offset, true);
-            offset += 2;
-            const roomId = new TextDecoder().decode(buffer.slice(offset, offset + roomIdLen));
-            offset += roomIdLen;
-            const snapshotLen = view.getUint32(offset, true);
-            offset += 4;
-            const snapshotJson = new TextDecoder().decode(buffer.slice(offset, offset + snapshotLen));
-            const { snapshot, snapshotHash } = JSON.parse(snapshotJson);
-            return { type: 'ROOM_CREATED', roomId, snapshot, snapshotHash };
-        }
-        case BinaryMessageType.ERROR: {
-            const msgLen = view.getUint16(1, true);
-            const message = new TextDecoder().decode(buffer.slice(3, 3 + msgLen));
-            return { type: 'ERROR', message };
-        }
-        case BinaryMessageType.SNAPSHOT_UPDATE: {
-            let offset = 1;
-            const roomIdLen = view.getUint16(offset, true);
-            offset += 2;
-            const roomId = new TextDecoder().decode(buffer.slice(offset, offset + roomIdLen));
-            offset += roomIdLen;
-            const snapshotLen = view.getUint32(offset, true);
-            offset += 4;
-            const snapshotJson = new TextDecoder().decode(buffer.slice(offset, offset + snapshotLen));
-            const { snapshot, snapshotHash } = JSON.parse(snapshotJson);
-            return { type: 'SNAPSHOT_UPDATE', roomId, snapshot, snapshotHash };
-        }
-        case BinaryMessageType.ROOM_LEFT: {
-            const roomIdLen = view.getUint16(1, true);
-            const roomId = new TextDecoder().decode(buffer.slice(3, 3 + roomIdLen));
-            return { type: 'ROOM_LEFT', roomId };
+            case BinaryMessageType.INITIAL_STATE: {
+                let offset = 1;
+                const frame = view.getUint32(offset, true);
+                offset += 4;
+                const roomIdLen = view.getUint16(offset, true);
+                offset += 2;
+                if (offset + roomIdLen > buffer.byteLength) {
+                    console.error('[modd-network] Buffer overflow reading INITIAL_STATE roomId');
+                    return null;
+                }
+                const roomId = new TextDecoder().decode(new Uint8Array(buffer, offset, roomIdLen));
+                offset += roomIdLen;
+                const snapshotLen = view.getUint32(offset, true);
+                offset += 4;
+                if (offset + snapshotLen > buffer.byteLength) {
+                    console.error('[modd-network] Buffer overflow reading INITIAL_STATE snapshot');
+                    return null;
+                }
+                const snapshotJson = new TextDecoder().decode(new Uint8Array(buffer, offset, snapshotLen));
+                offset += snapshotLen;
+                const inputsLen = view.getUint32(offset, true);
+                offset += 4;
+                if (offset + inputsLen > buffer.byteLength) {
+                    console.error('[modd-network] Buffer overflow reading INITIAL_STATE inputs');
+                    return null;
+                }
+                const inputsJson = new TextDecoder().decode(new Uint8Array(buffer, offset, inputsLen));
+                const { snapshot, snapshotHash } = JSON.parse(snapshotJson);
+                const events = JSON.parse(inputsJson);
+                return { type: 'INITIAL_STATE', frame, snapshot, snapshotHash, events };
+            }
+            case BinaryMessageType.ROOM_CREATED: {
+                let offset = 1;
+                const roomIdLen = view.getUint16(offset, true);
+                offset += 2;
+                const roomId = new TextDecoder().decode(new Uint8Array(buffer, offset, roomIdLen));
+                offset += roomIdLen;
+                const clientIdLen = view.getUint16(offset, true);
+                offset += 2;
+                const clientId = new TextDecoder().decode(new Uint8Array(buffer, offset, clientIdLen));
+                offset += clientIdLen;
+                const snapshotLen = view.getUint32(offset, true);
+                offset += 4;
+                const snapshotJson = new TextDecoder().decode(new Uint8Array(buffer, offset, snapshotLen));
+                const { snapshot, snapshotHash } = JSON.parse(snapshotJson);
+                return { type: 'ROOM_CREATED', roomId, clientId, snapshot, snapshotHash };
+            }
+            case BinaryMessageType.ROOM_JOINED: {
+                let offset = 1;
+                const roomIdLen = view.getUint16(offset, true);
+                offset += 2;
+                const roomId = new TextDecoder().decode(new Uint8Array(buffer, offset, roomIdLen));
+                offset += roomIdLen;
+                const clientIdLen = view.getUint16(offset, true);
+                offset += 2;
+                const clientId = new TextDecoder().decode(new Uint8Array(buffer, offset, clientIdLen));
+                return { type: 'ROOM_JOINED', roomId, clientId };
+            }
+            case BinaryMessageType.ERROR: {
+                const msgLen = view.getUint16(1, true);
+                const message = new TextDecoder().decode(new Uint8Array(buffer, 3, msgLen));
+                return { type: 'ERROR', message };
+            }
+            case BinaryMessageType.SNAPSHOT_UPDATE: {
+                let offset = 1;
+                const roomIdLen = view.getUint16(offset, true);
+                offset += 2;
+                const roomId = new TextDecoder().decode(new Uint8Array(buffer, offset, roomIdLen));
+                offset += roomIdLen;
+                const snapshotLen = view.getUint32(offset, true);
+                offset += 4;
+                const snapshotJson = new TextDecoder().decode(new Uint8Array(buffer, offset, snapshotLen));
+                const { snapshot, snapshotHash } = JSON.parse(snapshotJson);
+                return { type: 'SNAPSHOT_UPDATE', roomId, snapshot, snapshotHash };
+            }
+            case BinaryMessageType.ROOM_LEFT: {
+                const roomIdLen = view.getUint16(1, true);
+                const roomId = new TextDecoder().decode(new Uint8Array(buffer, 3, roomIdLen));
+                return { type: 'ROOM_LEFT', roomId };
+            }
+            case BinaryMessageType.CLIENT_LIST_UPDATE: {
+                let offset = 1;
+                const roomIdLen = view.getUint16(offset, true);
+                offset += 2;
+                const roomId = new TextDecoder().decode(new Uint8Array(buffer, offset, roomIdLen));
+                offset += roomIdLen;
+                const clientsLen = view.getUint32(offset, true);
+                offset += 4;
+                const clientsJson = new TextDecoder().decode(new Uint8Array(buffer, offset, clientsLen));
+                const clients = JSON.parse(clientsJson);
+                return { type: 'CLIENT_LIST_UPDATE', roomId, clients };
+            }
+            default:
+                return null;
         }
-        default:
-            return null;
+    }
+    catch (err) {
+        console.error('[modd-network] Decode error:', err);
+        return null;
     }
 }
-// Helper to normalize binary data to ArrayBuffer
 async function toArrayBuffer(data) {
-    if (data instanceof ArrayBuffer) {
+    if (data instanceof ArrayBuffer)
         return data;
-    }
-    if (typeof Blob !== 'undefined' && data instanceof Blob) {
+    if (typeof Blob !== 'undefined' && data instanceof Blob)
         return await data.arrayBuffer();
-    }
-    // Fallback for Buffer, ArrayBufferView, or array-like
-    // creating a new Uint8Array(data) copies the data to a new ArrayBuffer
     return new Uint8Array(data).buffer;
 }
-// ============================================
-// Main Connect Function
-// ============================================
-async function connect(roomId, options = {}) {
-    const appId = options.appId || 'app';
+async function connect(appId, roomId, options = {}) {
     const initialSnapshot = options.snapshot || {};
     const user = options.user || null;
     const onConnect = options.onConnect || (() => { });
@@ -152,17 +262,17 @@ async function connect(roomId, options = {}) {
     const onMessage = options.onMessage || (() => { });
     const onTick = options.onTick || null;
     const getStateHash = options.getStateHash || null;
-    // Determine central service URL
     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');
+    console.log('[modd-network] Central service URL:', centralServiceUrl);
     let connected = false;
-    let initialStateReceived = null;
     let deliveredSeqs = new Set();
     let pendingTicks = [];
     let ws = null;
     let nodeUrl = null;
-    // Bandwidth tracking
+    let nodeToken = null;
+    let connectionResolve = null;
     let bytesIn = 0;
     let bytesOut = 0;
     let lastBytesIn = 0;
@@ -170,280 +280,315 @@ async function connect(roomId, options = {}) {
     let bandwidthIn = 0;
     let bandwidthOut = 0;
     let bandwidthInterval = null;
-    // Hash sync tracking
     let hashInterval = null;
     let lastSyncSeq = 0;
     let lastSyncFrame = 0;
     let currentFrame = 0;
+    let myClientId = null;
+    // Process events to auto-register clientIds from join/leave 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') {
+                const clientId = data.clientId || event.clientId;
+                if (clientId) {
+                    registerClientId(clientId);
+                }
+            }
+            else if (eventType === 'leave') {
+                const clientId = data.clientId || event.clientId;
+                if (clientId) {
+                    unregisterClientId(clientId);
+                }
+            }
+        }
+    }
     try {
-        const res = await fetch(`${centralServiceUrl}/api/apps/${appId}/rooms/${roomId}/connect`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ creatorNodeId: options.creatorNodeId })
-        });
-        if (!res.ok) {
-            throw new Error(`Central service error: ${res.status}`);
+        // Allow direct node URL for testing cross-node scenarios
+        if (options.nodeUrl) {
+            nodeUrl = options.nodeUrl;
+            console.log('[modd-network] Using direct Node URL:', nodeUrl);
+        }
+        else {
+            const requestBody = {};
+            if (options.joinToken) {
+                requestBody.joinToken = options.joinToken;
+            }
+            const res = await fetch(`${centralServiceUrl}/api/apps/${appId}/rooms/${roomId}/connect`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(requestBody)
+            });
+            if (!res.ok) {
+                const errorData = await res.json().catch(() => ({ error: `HTTP ${res.status}` }));
+                throw new Error(errorData.error || `Central service error: ${res.status}`);
+            }
+            const responseData = await res.json();
+            nodeUrl = responseData.url;
+            nodeToken = responseData.token;
+            console.log('[modd-network] Received Node URL:', nodeUrl);
         }
-        const { url } = await res.json();
-        nodeUrl = url;
-        // Use imported WebSocket (work in Node) or global WebSocket if present (Browser)
-        // Note: importing 'ws' gives a constructor. In browser env, 'ws' module might be shimmed.
-        // However, for best compat, let's use globalThis.WebSocket if available, else WS.
-        const WS = (typeof globalThis !== 'undefined' && globalThis.WebSocket) ? globalThis.WebSocket : ws_1.default;
-        // @ts-ignore - TS might complain about mixing types
-        ws = new WS(nodeUrl);
-        ws.binaryType = 'arraybuffer'; // Ensure we get ArrayBuffer if possible (in Browser)
-        ws.onopen = () => {
-            bandwidthInterval = setInterval(() => {
-                bandwidthIn = bytesIn - lastBytesIn;
-                bandwidthOut = bytesOut - lastBytesOut;
-                lastBytesIn = bytesIn;
-                lastBytesOut = bytesOut;
-            }, 1000);
-            if (getStateHash) {
-                hashInterval = setInterval(() => {
+        const WS = (typeof globalThis !== 'undefined' && globalThis.WebSocket) ? globalThis.WebSocket : WebSocket;
+        return new Promise((resolve, reject) => {
+            connectionResolve = resolve;
+            // Append JWT token to WebSocket URL if provided by central service
+            const wsUrl = nodeToken ? `${nodeUrl}?token=${encodeURIComponent(nodeToken)}` : nodeUrl;
+            // @ts-ignore
+            ws = new WS(wsUrl);
+            ws.binaryType = 'arraybuffer';
+            const instance = {
+                send(data) {
                     if (!connected || !ws || ws.readyState !== 1)
                         return;
-                    try {
-                        const hash = getStateHash();
-                        if (hash) {
-                            const hashMsg = encodeSyncHash(roomId, hash, lastSyncSeq, lastSyncFrame);
-                            bytesOut += hashMsg.byteLength;
-                            ws.send(hashMsg);
-                        }
-                    }
-                    catch (err) {
-                        console.warn('[modd-network] Error getting state hash:', err);
+                    if (data?.type === 'playerState' && data.id) {
+                        const binary = (0, state_codec_1.encodePlayerState)(data);
+                        const wrapper = new Uint8Array(1 + binary.length);
+                        wrapper[0] = 0x20;
+                        wrapper.set(binary, 1);
+                        ws.send(wrapper);
+                        return;
                     }
-                }, 1000);
-            }
-            const joinMsg = JSON.stringify({ type: 'JOIN_ROOM', payload: { roomId } });
-            bytesOut += joinMsg.length;
-            ws.send(joinMsg);
-        };
-        ws.onerror = (e) => onError(`Failed to connect to ${nodeUrl}: ${e.message || 'Unknown error'}`);
-        ws.onclose = () => {
-            connected = false;
-            if (bandwidthInterval)
-                clearInterval(bandwidthInterval);
-            if (hashInterval)
-                clearInterval(hashInterval);
-            onDisconnect();
-        };
-        ws.onmessage = async (e) => {
-            // Handle various binary formats
-            let buffer;
-            try {
-                buffer = await toArrayBuffer(e.data);
-            }
-            catch (err) {
-                console.warn('[modd-network] Failed to read message data:', err);
-                return;
-            }
-            bytesIn += buffer.byteLength;
-            const msg = decodeBinaryMessage(buffer);
-            if (!msg) {
-                console.warn('[modd-network] Failed to decode binary message');
-                return;
-            }
-            switch (msg.type) {
-                case 'TICK': {
-                    if (!connected) {
-                        pendingTicks.push(msg);
-                        break;
+                    if (data?.type === 'entityState' && data.id) {
+                        const binary = (0, state_codec_1.encodeEntityState)(data);
+                        const wrapper = new Uint8Array(1 + binary.length);
+                        wrapper[0] = 0x20;
+                        wrapper.set(binary, 1);
+                        ws.send(wrapper);
+                        return;
                     }
-                    currentFrame = msg.frame;
-                    lastSyncFrame = msg.frame;
-                    if (msg.inputs && msg.inputs.length > 0) {
-                        const maxSeq = Math.max(...msg.inputs.map(i => i.sequenceNumber || 0));
-                        if (maxSeq > lastSyncSeq)
-                            lastSyncSeq = maxSeq;
+                    if (data?.type === 'inputState' && data.id) {
+                        const binary = (0, state_codec_1.encodeInputState)(data);
+                        const wrapper = new Uint8Array(1 + binary.length);
+                        wrapper[0] = 0x20;
+                        wrapper.set(binary, 1);
+                        ws.send(wrapper);
+                        return;
                     }
-                    if (onTick) {
-                        const newInputs = msg.inputs.filter(i => !deliveredSeqs.has(i.sequenceNumber));
-                        newInputs.forEach(i => deliveredSeqs.add(i.sequenceNumber));
-                        onTick(msg.frame, newInputs);
+                    const msg = JSON.stringify({ type: 'SEND_INPUT', payload: { roomId, data } });
+                    bytesOut += msg.length;
+                    ws.send(msg);
+                },
+                sendSnapshot(snapshot, hash) {
+                    if (connected && ws) {
+                        const msg = JSON.stringify({ type: 'SEND_SNAPSHOT', payload: { roomId, snapshot, hash } });
+                        bytesOut += msg.length;
+                        ws.send(msg);
                     }
-                    break;
-                }
-                case 'ERROR': {
-                    if (msg.message === 'Room not found') {
-                        const createMsg = JSON.stringify({
-                            type: 'CREATE_ROOM',
-                            payload: { roomId, appId, snapshot: initialSnapshot }
-                        });
-                        bytesOut += createMsg.length;
-                        ws.send(createMsg);
+                },
+                leaveRoom() {
+                    if (connected && user && ws) {
+                        const msg = JSON.stringify({ type: 'SEND_INPUT', payload: { roomId, data: { type: 'leave', user } } });
+                        bytesOut += msg.length;
+                        ws.send(msg);
                     }
-                    else {
-                        onError(msg.message);
+                    if (ws)
+                        ws.close();
+                },
+                getClients() {
+                    if (connected && ws && ws.readyState === 1) {
+                        const msg = JSON.stringify({ type: 'GET_CLIENTS', payload: { roomId } });
+                        bytesOut += msg.length;
+                        ws.send(msg);
                     }
-                    break;
+                },
+                close() {
+                    if (ws)
+                        ws.close();
+                },
+                get connected() { return connected; },
+                get clientId() { return myClientId; },
+                get node() { return nodeUrl ? (nodeUrl.match(/:(\d+)/)?.[1] || nodeUrl) : null; },
+                get bandwidthIn() { return bandwidthIn; },
+                get bandwidthOut() { return bandwidthOut; },
+                get totalBytesIn() { return bytesIn; },
+                get totalBytesOut() { return bytesOut; },
+                get frame() { return currentFrame; },
+                getLatency() { return '0'; }
+            };
+            ws.onopen = () => {
+                bandwidthInterval = setInterval(() => {
+                    bandwidthIn = bytesIn - lastBytesIn;
+                    bandwidthOut = bytesOut - lastBytesOut;
+                    lastBytesIn = bytesIn;
+                    lastBytesOut = bytesOut;
+                }, 1000);
+                if (getStateHash) {
+                    hashInterval = setInterval(() => {
+                        if (!connected || !ws || ws.readyState !== 1)
+                            return;
+                        try {
+                            const hash = getStateHash();
+                            if (hash) {
+                                const hashMsg = encodeSyncHash(roomId, hash, lastSyncSeq, lastSyncFrame);
+                                bytesOut += hashMsg.byteLength;
+                                ws.send(hashMsg);
+                            }
+                        }
+                        catch (err) {
+                            console.warn('[modd-network] Error getting state hash:', err);
+                        }
+                    }, 1000);
                 }
-                case 'ROOM_CREATED': {
-                    connected = true;
-                    if (user) {
-                        const joinInputMsg = JSON.stringify({ type: 'SEND_INPUT', payload: { roomId, data: { type: 'join', user } } });
-                        bytesOut += joinInputMsg.length;
-                        ws.send(joinInputMsg);
-                    }
-                    onConnect(initialSnapshot, []);
-                    break;
+                // Include user metadata - server will generate the join event
+                const joinMsg = JSON.stringify({ type: 'JOIN_ROOM', payload: { roomId, user } });
+                bytesOut += joinMsg.length;
+                ws.send(joinMsg);
+            };
+            ws.onerror = (e) => {
+                const errMsg = `Failed to connect to ${nodeUrl}: ${e.message || 'Unknown error'}`;
+                onError(errMsg);
+                if (!connected)
+                    reject(new Error(errMsg));
+            };
+            ws.onclose = () => {
+                connected = false;
+                if (bandwidthInterval)
+                    clearInterval(bandwidthInterval);
+                if (hashInterval)
+                    clearInterval(hashInterval);
+                onDisconnect();
+            };
+            ws.onmessage = async (e) => {
+                let buffer;
+                try {
+                    buffer = await toArrayBuffer(e.data);
                 }
-                case 'INITIAL_STATE': {
-                    initialStateReceived = {
-                        snapshot: msg.snapshot,
-                        inputs: msg.inputs || [],
-                        frame: msg.frame
-                    };
-                    lastSyncFrame = msg.frame;
-                    if (msg.inputs && msg.inputs.length > 0) {
-                        const maxSeq = Math.max(...msg.inputs.map(i => i.sequenceNumber || 0));
-                        if (maxSeq > lastSyncSeq)
-                            lastSyncSeq = maxSeq;
-                    }
-                    break;
+                catch (err) {
+                    console.warn('[modd-network] Failed to read message data:', err);
+                    return;
                 }
-                case 'ROOM_JOINED': {
-                    connected = true;
-                    if (user) {
-                        const joinInputMsg = JSON.stringify({ type: 'SEND_INPUT', payload: { roomId, data: { type: 'join', user } } });
-                        bytesOut += joinInputMsg.length;
-                        ws.send(joinInputMsg);
+                bytesIn += buffer.byteLength;
+                const msg = decodeBinaryMessage(buffer);
+                console.log("decoded msg: ", msg);
+                if (!msg)
+                    return;
+                switch (msg.type) {
+                    case 'TICK': {
+                        if (!connected) {
+                            pendingTicks.push(msg);
+                            break;
+                        }
+                        currentFrame = msg.frame;
+                        lastSyncFrame = msg.frame;
+                        if (msg.events && msg.events.length > 0) {
+                            const maxSeq = Math.max(...msg.events.map(e => e.seq || 0));
+                            if (maxSeq > lastSyncSeq)
+                                lastSyncSeq = maxSeq;
+                        }
+                        const newEvents = msg.events.filter(e => !deliveredSeqs.has(e.seq));
+                        newEvents.forEach(e => deliveredSeqs.add(e.seq));
+                        // Auto-register clientIds from join/leave events
+                        if (newEvents.length > 0) {
+                            processEventsForClientIds(newEvents);
+                        }
+                        if (onTick) {
+                            onTick(msg.frame, newEvents);
+                        }
+                        break;
                     }
-                    const processInitialState = () => {
-                        if (initialStateReceived) {
-                            const { snapshot, inputs, frame } = initialStateReceived;
-                            onConnect(snapshot, inputs);
-                            const newInputs = inputs.filter(i => !deliveredSeqs.has(i.sequenceNumber));
-                            newInputs.forEach(i => deliveredSeqs.add(i.sequenceNumber));
-                            if (onTick && newInputs.length > 0) {
-                                onTick(frame, newInputs, true);
-                            }
-                            else {
-                                newInputs.forEach(i => onMessage(i.data, i.sequenceNumber));
-                            }
-                            initialStateReceived = null;
-                            // Process buffered ticks
-                            if (pendingTicks.length > 0) {
-                                pendingTicks.sort((a, b) => a.frame - b.frame);
-                                for (const tickMsg of pendingTicks) {
-                                    if (onTick) {
-                                        const tickInputs = tickMsg.inputs.filter(i => !deliveredSeqs.has(i.sequenceNumber));
-                                        tickInputs.forEach(i => deliveredSeqs.add(i.sequenceNumber));
-                                        if (tickInputs.length > 0 || tickMsg.frame > frame) {
-                                            onTick(tickMsg.frame, tickInputs);
-                                        }
-                                    }
+                    case 'ERROR': {
+                        if (msg.message === 'Room not found') {
+                            // Include user metadata - server will generate the join event
+                            const createMsg = JSON.stringify({
+                                type: 'CREATE_ROOM',
+                                payload: { roomId, snapshot: initialSnapshot, user }
+                            });
+                            bytesOut += createMsg.length;
+                            ws.send(createMsg);
+                        }
+                        else {
+                            onError(msg.message);
+                            reject(new Error(msg.message));
+                        }
+                        break;
+                    }
+                    case 'ROOM_CREATED': {
+                        connected = true;
+                        currentFrame = 0;
+                        // Server tells us our clientId - register it for hash lookup
+                        if (msg.clientId) {
+                            myClientId = msg.clientId;
+                            registerClientId(msg.clientId);
+                            console.log(`[modd-network] Assigned clientId: ${msg.clientId}`);
+                        }
+                        // Server generates join event - don't send one from client
+                        onConnect(initialSnapshot, [], 0, nodeUrl);
+                        if (connectionResolve)
+                            connectionResolve(instance);
+                        break;
+                    }
+                    case 'INITIAL_STATE': {
+                        console.log('[modd-network] Received INITIAL_STATE, connecting...');
+                        const { snapshot, events, frame } = msg;
+                        currentFrame = frame;
+                        lastSyncFrame = frame;
+                        if (events && events.length > 0) {
+                            const maxSeq = Math.max(...events.map(e => e.seq || 0));
+                            if (maxSeq > lastSyncSeq)
+                                lastSyncSeq = maxSeq;
+                        }
+                        // Auto-register clientIds from join events in history
+                        if (events && events.length > 0) {
+                            processEventsForClientIds(events);
+                        }
+                        // Treat INITIAL_STATE as proof of connection and readiness
+                        connected = true;
+                        onConnect(snapshot, events || [], frame, nodeUrl);
+                        // Process pending ticks
+                        if (pendingTicks.length > 0) {
+                            pendingTicks.sort((a, b) => a.frame - b.frame);
+                            for (const tickMsg of pendingTicks) {
+                                const tickEvents = tickMsg.events.filter(e => !deliveredSeqs.has(e.seq));
+                                tickEvents.forEach(e => deliveredSeqs.add(e.seq));
+                                // Auto-register clientIds from pending ticks too
+                                if (tickEvents.length > 0) {
+                                    processEventsForClientIds(tickEvents);
+                                }
+                                if (onTick && (tickEvents.length > 0 || tickMsg.frame > frame)) {
+                                    onTick(tickMsg.frame, tickEvents);
                                 }
-                                pendingTicks = [];
                             }
+                            pendingTicks = [];
                         }
-                        else {
-                            onConnect(null, []);
+                        if (connectionResolve)
+                            connectionResolve(instance);
+                        break;
+                    }
+                    case 'ROOM_JOINED': {
+                        // Server tells us our clientId - register it for hash lookup
+                        connected = true;
+                        if (msg.clientId) {
+                            myClientId = msg.clientId;
+                            registerClientId(msg.clientId);
+                            console.log(`[modd-network] Assigned clientId: ${msg.clientId}`);
                         }
-                    };
-                    if (initialStateReceived) {
-                        processInitialState();
+                        break;
                     }
-                    else {
-                        setTimeout(processInitialState, 100);
+                    case 'SNAPSHOT_UPDATE': {
+                        if (options.onSnapshot)
+                            options.onSnapshot(msg.snapshot, msg.snapshotHash);
+                        break;
                     }
-                    break;
-                }
-                case 'SNAPSHOT_UPDATE': {
-                    if (options.onSnapshot) {
-                        options.onSnapshot(msg.snapshot, msg.snapshotHash);
+                    case 'ROOM_LEFT': {
+                        console.log(`[modd-network] Left room ${msg.roomId}`);
+                        break;
+                    }
+                    case 'CLIENT_LIST_UPDATE': {
+                        if (options.onClientsUpdate)
+                            options.onClientsUpdate(msg.clients);
+                        break;
                     }
-                    break;
-                }
-                case 'ROOM_LEFT': {
-                    console.log(`[modd-network] Left room ${msg.roomId}`);
-                    break;
-                }
-            }
-        };
-        // Auto leave on page unload
-        if (user && typeof window !== 'undefined') {
-            window.addEventListener('beforeunload', () => {
-                if (connected && ws) {
-                    const leaveMsg = JSON.stringify({ type: 'SEND_INPUT', payload: { roomId, data: { type: 'leave', user } } });
-                    bytesOut += leaveMsg.length;
-                    ws.send(leaveMsg);
-                }
-            });
-        }
-        return {
-            send(data) {
-                if (connected && ws) {
-                    const msg = JSON.stringify({ type: 'SEND_INPUT', payload: { roomId, data } });
-                    bytesOut += msg.length;
-                    ws.send(msg);
-                }
-            },
-            sendSnapshot(snapshot, hash) {
-                if (connected && ws) {
-                    const msg = JSON.stringify({ type: 'SEND_SNAPSHOT', payload: { roomId, snapshot, hash } });
-                    bytesOut += msg.length;
-                    ws.send(msg);
-                }
-            },
-            leaveRoom() {
-                if (connected && user && ws) {
-                    const msg = JSON.stringify({ type: 'SEND_INPUT', payload: { roomId, data: { type: 'leave', user } } });
-                    bytesOut += msg.length;
-                    ws.send(msg);
                 }
-                if (ws)
-                    ws.close();
-            },
-            close() {
-                if (ws)
-                    ws.close();
-            },
-            get connected() {
-                return connected;
-            },
-            get node() {
-                return nodeUrl ? (nodeUrl.match(/:(\d+)/)?.[1] || nodeUrl) : null;
-            },
-            get bandwidthIn() {
-                return bandwidthIn;
-            },
-            get bandwidthOut() {
-                return bandwidthOut;
-            },
-            get totalBytesIn() {
-                return bytesIn;
-            },
-            get totalBytesOut() {
-                return bytesOut;
-            },
-            get frame() {
-                return currentFrame;
-            }
-        };
+            };
+        });
     }
     catch (err) {
-        onError(`Failed to get node assignment: ${err.message}`);
-        return {
-            send() { },
-            sendSnapshot() { },
-            leaveRoom() { },
-            close() { },
-            get connected() { return false; },
-            get node() { return null; },
-            get bandwidthIn() { return 0; },
-            get bandwidthOut() { return 0; },
-            get totalBytesIn() { return 0; },
-            get totalBytesOut() { return 0; },
-            get frame() { return 0; }
-        };
+        throw new Error(`Failed to get node assignment: ${err.message}`);
     }
 }
-// Legacy alias for backwards compatibility
 exports.modd = connect;
-// Browser global fallback
 if (typeof window !== 'undefined') {
     window.moddNetwork = { connect, modd: exports.modd };
 }