spoint 0.1.0 → 0.1.10

package/src/client/PhysicsNetworkClient.js

@@ -1,20 +1,21 @@
-import { PredictionEngine } from './PredictionEngine.js'
 import { pack, unpack } from '../protocol/msgpack.js'
 import { MSG } from '../protocol/MessageTypes.js'
+import { ReconnectManager } from './ReconnectManager.js'
+import { SnapshotProcessor } from './SnapshotProcessor.js'
+import { MessageHandler } from './MessageHandler.js'
 
 export class PhysicsNetworkClient {
   constructor(config = {}) {
-    this.config = { url: config.url || 'ws://localhost:8080/ws', tickRate: config.tickRate || 128, predictionEnabled: config.predictionEnabled !== false, debug: config.debug || false, ...config }
+    this.config = { url: config.url || 'ws://localhost:3000/ws', tickRate: config.tickRate || 128, predictionEnabled: config.predictionEnabled !== false, smoothInterpolation: config.smoothInterpolation !== false, debug: config.debug || false, ...config }
     this.ws = null
-    this.playerId = null
     this.connected = false
-    this._predEngine = null
-    this._playerStates = new Map()
-    this._entityStates = new Map()
+    this.state = { players: [], entities: [] }
     this.lastSnapshotTick = 0
     this.currentTick = 0
-    this.state = { players: [], entities: [] }
+    this._pingSent = 0
     this.heartbeatTimer = null
+    this._destroyed = false
+    this._visibilityListener = null
     this.callbacks = {
       onConnect: config.onConnect || (() => {}),
       onDisconnect: config.onDisconnect || (() => {}),
@@ -28,41 +29,63 @@ export class PhysicsNetworkClient {
       onWorldDef: config.onWorldDef || (() => {}),
       onAppModule: config.onAppModule || (() => {}),
       onAssetUpdate: config.onAssetUpdate || (() => {}),
-      onAppEvent: config.onAppEvent || (() => {})
+      onAppEvent: config.onAppEvent || (() => {}),
+      onHotReload: config.onHotReload || (() => {})
     }
+    this._reconnect = new ReconnectManager(config)
+    this._snapProc = new SnapshotProcessor({ callbacks: this.callbacks })
+    this._msgHandler = new MessageHandler({ ...config, callbacks: this.callbacks })
   }
 
+  get playerId() { return this._msgHandler.getPlayerId() }
+
   async connect() {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
+      let settled = false
       try {
         this.ws = new WebSocket(this.config.url)
         this.ws.binaryType = 'arraybuffer'
-        this.ws.onopen = () => this._onOpen(resolve)
+        this.ws.onopen = () => { settled = true; this._onOpen(resolve) }
         this.ws.onmessage = (event) => this.onMessage(event.data)
         this.ws.onclose = () => this._onClose()
-        this.ws.onerror = (error) => this._onError(error, reject)
-      } catch (error) { reject(error) }
+        this.ws.onerror = () => { if (!settled) { settled = true; resolve() } }
+      } catch (e) { resolve() }
     })
   }
 
   _onOpen(resolve) {
     this.connected = true
     this._startHeartbeat()
+    this._reconnect.sendReconnectMessage(this.ws)
+    this._reconnect.onConnected()
     this.callbacks.onConnect()
-    resolve()
+    resolve?.()
   }
 
   _onClose() {
     this.connected = false
     this._stopHeartbeat()
     this.callbacks.onDisconnect()
+    this._reconnect.onDisconnected(() => this._doReconnect())
   }
 
-  _onError(error, reject) { reject(error) }
+  _doReconnect() {
+    try {
+      this.ws = new WebSocket(this.config.url)
+      this.ws.binaryType = 'arraybuffer'
+      this.ws.onopen = () => this._onOpen(null)
+      this.ws.onmessage = (event) => this.onMessage(event.data)
+      this.ws.onclose = () => this._onClose()
+      this.ws.onerror = () => {}
+    } catch (e) {
+      this._reconnect.onDisconnected(() => this._doReconnect())
+    }
+  }
 
   sendInput(input) {
     if (!this._isOpen()) return
-    if (this.config.predictionEnabled && this._predEngine) this._predEngine.addInput(input)
+    const predEngine = this._msgHandler.getPredEngine()
+    if (this.config.predictionEnabled && predEngine) predEngine.addInput(input)
     this.ws.send(pack({ type: MSG.INPUT, payload: { input } }))
   }
 
@@ -71,89 +94,120 @@ export class PhysicsNetworkClient {
     this.ws.send(pack({ type: MSG.APP_EVENT, payload: { type: 'fire', shooterId: this.playerId, ...data } }))
   }
 
-  _isOpen() { return this.ws && this.ws.readyState === WebSocket.OPEN }
+  sendReload() {
+    if (!this._isOpen()) return
+    this.ws.send(pack({ type: MSG.APP_EVENT, payload: { type: 'reload', playerId: this.playerId } }))
+  }
+
+  _isOpen() {
+    return this.ws && this.ws.readyState === WebSocket.OPEN
+  }
 
   onMessage(data) {
     try {
       const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data
       const msg = unpack(bytes)
       this._handleMessage(msg.type, msg.payload || {})
-    } catch (e) { console.error('[client] parse error:', e) }
+    } catch (e) {
+      console.error('[client] parse error:', e)
+    }
   }
 
   _handleMessage(type, payload) {
-    if (type === MSG.HANDSHAKE_ACK) {
-      this.playerId = payload.playerId
-      this.currentTick = payload.tick
-      this._predEngine = new PredictionEngine(this.config.tickRate)
-      this._predEngine.init(this.playerId)
-    } else if (type === MSG.SNAPSHOT || type === MSG.STATE_CORRECTION) {
-      this._onSnapshot(payload)
-    } else if (type === MSG.PLAYER_LEAVE) {
-      this._playerStates.delete(payload.playerId)
-      this.callbacks.onPlayerLeft(payload.playerId)
-    } else if (type === MSG.WORLD_DEF) {
-      if (payload.movement && this._predEngine) this._predEngine.setMovement(payload.movement)
-      if (payload.gravity && this._predEngine) this._predEngine.setGravity(payload.gravity)
-      this.callbacks.onWorldDef?.(payload)
-    } else if (type === MSG.APP_EVENT) {
-      this.callbacks.onAppEvent?.(payload)
-    } else if (type === MSG.HOT_RELOAD || type === MSG.APP_MODULE || type === MSG.ASSET_UPDATE) {
-      const cb = { [MSG.HOT_RELOAD]: 'onHotReload', [MSG.APP_MODULE]: 'onAppModule', [MSG.ASSET_UPDATE]: 'onAssetUpdate' }[type]
-      this.callbacks[cb]?.(payload)
+    const result = this._msgHandler.handleMessage(type, payload, this._snapProc)
+    if (type === MSG.HANDSHAKE_ACK && result?.sessionToken) {
+      this._reconnect.setSessionToken(result.sessionToken)
+    } else if (type === MSG.RECONNECT_ACK && result?.sessionToken) {
+      this._reconnect.setSessionToken(result.sessionToken)
+    } else if (result?.invalidate) {
+      this._reconnect.invalidateSession()
+    } else if (result && (type === MSG.SNAPSHOT || type === MSG.STATE_CORRECTION || type === MSG.STATE_RECOVERY)) {
+      this._onSnapshot(result)
     }
   }
 
   _onSnapshot(data) {
     this.lastSnapshotTick = this.currentTick = data.tick || 0
-    for (const p of data.players || []) {
-      const { playerId, state } = this._parsePlayer(p)
-      if (!this._playerStates.has(playerId)) this.callbacks.onPlayerJoined(playerId, state)
-      this._playerStates.set(playerId, state)
-      if (playerId === this.playerId && this.config.predictionEnabled && this._predEngine) {
-        this._predEngine.onServerSnapshot({ players: [state] }, this.currentTick)
-      }
+    const snapshotForBuffer = this._snapProc.processSnapshot(data, this.currentTick)
+    const smoothInterp = this._msgHandler.getSmoothInterp()
+    if (smoothInterp) {
+      smoothInterp.addSnapshot(snapshotForBuffer)
     }
-    for (const e of data.entities || []) {
-      const { entityId, state } = this._parseEntity(e)
-      if (!this._entityStates.has(entityId)) this.callbacks.onEntityAdded(entityId, state)
-      this._entityStates.set(entityId, state)
+    const predEngine = this._msgHandler.getPredEngine()
+    if (this.playerId && this.config.predictionEnabled && predEngine) {
+      const localState = this._snapProc.getPlayerState(this.playerId)
+      if (localState) {
+        predEngine.onServerSnapshot({ players: [localState] }, this.currentTick)
+      }
     }
-    this.state.players = Array.from(this._playerStates.values())
-    this.state.entities = Array.from(this._entityStates.values())
+    this.state.players = Array.from(this._snapProc.getAllPlayerStates().values())
+    this.state.entities = Array.from(this._snapProc.getAllEntities().values())
     this.callbacks.onSnapshot(data)
     this.callbacks.onStateUpdate(this.state)
     this._render()
   }
 
-  _parsePlayer(p) {
-    if (Array.isArray(p)) return { playerId: p[0], state: { id: p[0], position: [p[1], p[2], p[3]], rotation: [p[4], p[5], p[6], p[7]], velocity: [p[8], p[9], p[10]], onGround: p[11] === 1, health: p[12], inputSequence: p[13] } }
-    return { playerId: p.id || p.i, state: { id: p.id || p.i, position: p.position || [0, 0, 0], rotation: p.rotation || [0, 0, 0, 1], velocity: p.velocity || [0, 0, 0], onGround: p.onGround ?? false, health: p.health ?? 100 } }
-  }
-
-  _parseEntity(e) {
-    if (Array.isArray(e)) return { entityId: e[0], state: { id: e[0], model: e[1], position: [e[2], e[3], e[4]], rotation: [e[5], e[6], e[7], e[8]], bodyType: e[9], custom: e[10] } }
-    return { entityId: e.id, state: { id: e.id, model: e.model, position: e.position || [0, 0, 0], rotation: e.rotation || [0, 0, 0, 1], bodyType: e.bodyType || 'static', custom: e.custom || null } }
-  }
-
   _render() {
     const displayStates = new Map()
-    for (const [playerId, serverState] of this._playerStates) {
-      displayStates.set(playerId, playerId === this.playerId && this.config.predictionEnabled && this._predEngine ? this._predEngine.getDisplayState(this.currentTick, 0) : serverState)
+    const smoothInterp = this._msgHandler.getSmoothInterp()
+    if (smoothInterp) {
+      const smoothState = smoothInterp.getDisplayState()
+      for (const p of smoothState.players) {
+        displayStates.set(p.id, p)
+      }
+    } else {
+      const predEngine = this._msgHandler.getPredEngine()
+      for (const [playerId, serverState] of this._snapProc.getAllPlayerStates()) {
+        if (playerId === this.playerId && this.config.predictionEnabled && predEngine) {
+          displayStates.set(playerId, predEngine.getDisplayState(this.currentTick, 0))
+        } else {
+          displayStates.set(playerId, serverState)
+        }
+      }
     }
     this.callbacks.onRender(displayStates)
   }
 
+  getSmoothState() {
+    const smoothInterp = this._msgHandler.getSmoothInterp()
+    if (smoothInterp) {
+      return smoothInterp.getDisplayState()
+    }
+    return { players: this.state.players, entities: this.state.entities }
+  }
+
+  getRTT() {
+    return this._msgHandler.getRTT()
+  }
+
+  getBufferHealth() {
+    return this._msgHandler.getBufferHealth()
+  }
+
   getLocalState() {
-    return this.config.predictionEnabled && this._predEngine ? this._predEngine.localState : this._playerStates.get(this.playerId)
+    const predEngine = this._msgHandler.getPredEngine()
+    return this.config.predictionEnabled && predEngine ? predEngine.localState : this._snapProc.getPlayerState(this.playerId)
   }
 
-  getRemoteState(playerId) { return this._playerStates.get(playerId) }
-  getAllStates() { return new Map(this._playerStates) }
-  getEntity(entityId) { return this._entityStates.get(entityId) }
-  getAllEntities() { return new Map(this._entityStates) }
+  getRemoteState(playerId) {
+    return this._snapProc.getPlayerState(playerId)
+  }
+
+  getAllStates() {
+    return this._snapProc.getAllPlayerStates()
+  }
+
+  getEntity(entityId) {
+    return this._snapProc.getEntity(entityId)
+  }
+
+  getAllEntities() {
+    return this._snapProc.getAllEntities()
+  }
 
   disconnect() {
+    this._destroyed = true
+    this._reconnect.clear()
     this._stopHeartbeat()
     if (this.ws) this.ws.close()
   }
@@ -161,11 +215,30 @@ export class PhysicsNetworkClient {
   _startHeartbeat() {
     this._stopHeartbeat()
     this.heartbeatTimer = setInterval(() => {
-      if (this._isOpen()) this.ws.send(pack({ type: MSG.HEARTBEAT, payload: {} }))
+      if (this._isOpen()) {
+        this._pingSent = Date.now()
+        this.ws.send(pack({ type: MSG.HEARTBEAT, payload: { timestamp: this._pingSent } }))
+      }
     }, 1000)
+    if (typeof document !== 'undefined' && !this._visibilityListener) {
+      this._visibilityListener = () => {
+        if (!document.hidden && this._isOpen()) {
+          this._pingSent = Date.now()
+          this.ws.send(pack({ type: MSG.HEARTBEAT, payload: { timestamp: this._pingSent } }))
+        }
+      }
+      document.addEventListener('visibilitychange', this._visibilityListener)
+    }
   }
 
   _stopHeartbeat() {
-    if (this.heartbeatTimer) { clearInterval(this.heartbeatTimer); this.heartbeatTimer = null }
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = null
+    }
+    if (this._visibilityListener && typeof document !== 'undefined') {
+      document.removeEventListener('visibilitychange', this._visibilityListener)
+      this._visibilityListener = null
+    }
   }
 }

package/src/client/ReconnectManager.js

@@ -0,0 +1,62 @@
+import { pack } from '../protocol/msgpack.js'
+import { MSG } from '../protocol/MessageTypes.js'
+
+export class ReconnectManager {
+  constructor(config = {}) {
+    this._sessionToken = null
+    this._reconnectAttempts = 0
+    this._reconnectTimer = null
+    this._reconnecting = false
+    this._maxReconnectDelay = config.maxReconnectDelay || 5000
+    this._destroyed = false
+  }
+
+  setSessionToken(token) {
+    this._sessionToken = token
+  }
+
+  isReconnecting() {
+    return this._reconnecting
+  }
+
+  sendReconnectMessage(ws) {
+    if (this._sessionToken && this._reconnecting && ws?.readyState === WebSocket.OPEN) {
+      ws.send(pack({ type: MSG.RECONNECT, payload: { sessionToken: this._sessionToken } }))
+    }
+  }
+
+  onConnected() {
+    this._reconnectAttempts = 0
+    this._reconnecting = false
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer)
+      this._reconnectTimer = null
+    }
+  }
+
+  onDisconnected(callback) {
+    if (this._destroyed) return
+    if (this._reconnectTimer) return
+    const delay = Math.min(1000 * Math.pow(1.5, this._reconnectAttempts), this._maxReconnectDelay)
+    this._reconnectAttempts++
+    this._reconnecting = true
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null
+      if (!this._destroyed) callback()
+    }, delay)
+  }
+
+  clear() {
+    this._destroyed = true
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer)
+      this._reconnectTimer = null
+    }
+    this._sessionToken = null
+  }
+
+  invalidateSession() {
+    this._sessionToken = null
+    this._reconnecting = false
+  }
+}

package/src/client/SmoothInterpolation.js

@@ -0,0 +1,127 @@
+import { KalmanFilter3D, SmoothStateTracker } from './KalmanFilter.js'
+import { JitterBuffer } from './JitterBuffer.js'
+
+export class SmoothInterpolation {
+  constructor(config = {}) {
+    this.jitterBuffer = new JitterBuffer(config.jitter || {})
+    this.playerFilters = new Map()
+    this.entityFilters = new Map()
+    this.kalmanConfig = config.kalman || {
+      processNoise: 0.08,
+      measurementNoise: 0.3,
+      uncertainty: 0.5
+    }
+    
+    this.lastFrameTime = Date.now()
+    this.localPlayerId = null
+    this.predictionEnabled = config.predictionEnabled !== false
+    this.extrapolationLimit = config.extrapolationLimit || 100
+  }
+  
+  setLocalPlayer(id) {
+    this.localPlayerId = id
+  }
+  
+  addSnapshot(snapshot) {
+    this.jitterBuffer.addSnapshot(snapshot)
+  }
+  
+  getDisplayState(now = Date.now()) {
+    const snapshot = this.jitterBuffer.getSnapshotToRender(now)
+    if (!snapshot) return { players: [], entities: [] }
+    
+    const dt = Math.min((now - this.lastFrameTime) / 1000, 0.1)
+    this.lastFrameTime = now
+    
+    const displayPlayers = []
+    for (const player of snapshot.players || []) {
+      if (player.id === this.localPlayerId && this.predictionEnabled) {
+        displayPlayers.push(player)
+        continue
+      }
+      
+      const smoothed = this._smoothPlayer(player, dt)
+      displayPlayers.push(smoothed)
+    }
+    
+    const displayEntities = []
+    for (const entity of snapshot.entities || []) {
+      const smoothed = this._smoothEntity(entity, dt)
+      displayEntities.push(smoothed)
+    }
+    
+    return { players: displayPlayers, entities: displayEntities }
+  }
+  
+  _smoothPlayer(player, dt) {
+    let filter = this.playerFilters.get(player.id)
+    if (!filter) {
+      filter = new KalmanFilter3D(this.kalmanConfig)
+      this.playerFilters.set(player.id, filter)
+    }
+    
+    const state = filter.update(player.position, player.velocity)
+    
+    return {
+      ...player,
+      position: state.position,
+      velocity: state.velocity
+    }
+  }
+  
+  _smoothEntity(entity, dt) {
+    let filter = this.entityFilters.get(entity.id)
+    if (!filter) {
+      filter = new KalmanFilter3D(this.kalmanConfig)
+      this.entityFilters.set(entity.id, filter)
+    }
+    
+    const state = filter.update(entity.position)
+    
+    return {
+      ...entity,
+      position: state.position
+    }
+  }
+  
+  predictStep(dt) {
+    for (const [id, filter] of this.playerFilters) {
+      filter.predict(dt)
+    }
+    for (const [id, filter] of this.entityFilters) {
+      filter.predict(dt)
+    }
+  }
+  
+  removePlayer(id) {
+    this.playerFilters.delete(id)
+  }
+  
+  removeEntity(id) {
+    this.entityFilters.delete(id)
+  }
+  
+  updateRTT(pingTime, pongTime) {
+    this.jitterBuffer.updateRTT(pingTime, pongTime)
+  }
+  
+  getRTT() {
+    return this.jitterBuffer.getRTT()
+  }
+  
+  getBufferHealth() {
+    return this.jitterBuffer.getBufferHealth()
+  }
+  
+  reset() {
+    this.jitterBuffer.clear()
+    this.playerFilters.clear()
+    this.entityFilters.clear()
+  }
+  
+  setConfig(config) {
+    if (config.kalman) {
+      this.kalmanConfig = { ...this.kalmanConfig, ...config.kalman }
+    }
+  }
+}

package/src/client/SnapshotProcessor.js

@@ -0,0 +1,144 @@
+export class SnapshotProcessor {
+  constructor(config = {}) {
+    this._playerStates = new Map()
+    this._entityStates = new Map()
+    this.lastSnapshotTick = 0
+    this._callbacks = config.callbacks || {}
+  }
+
+  processSnapshot(data, tick) {
+    this.lastSnapshotTick = tick
+
+    const snapshotForBuffer = {
+      tick: data.tick || 0,
+      timestamp: data.timestamp || Date.now(),
+      players: [],
+      entities: []
+    }
+
+    const seenPlayers = new Set()
+    for (const p of data.players || []) {
+      const { playerId, state } = this._parsePlayer(p)
+      seenPlayers.add(playerId)
+      if (!this._playerStates.has(playerId)) {
+        this._callbacks.onPlayerJoined?.(playerId, state)
+      }
+      this._playerStates.set(playerId, state)
+      snapshotForBuffer.players.push(state)
+    }
+
+    for (const playerId of this._playerStates.keys()) {
+      if (!seenPlayers.has(playerId)) {
+        this._playerStates.delete(playerId)
+        this._callbacks.onPlayerLeft?.(playerId)
+      }
+    }
+
+    this._processEntities(data, snapshotForBuffer)
+    return snapshotForBuffer
+  }
+
+  _processEntities(data, snapshotForBuffer) {
+    if (data.delta) {
+      for (const e of data.entities || []) {
+        const { entityId, state } = this._parseEntity(e)
+        if (!this._entityStates.has(entityId)) {
+          this._callbacks.onEntityAdded?.(entityId, state)
+        }
+        this._entityStates.set(entityId, state)
+        snapshotForBuffer.entities.push(state)
+      }
+      if (data.removed) {
+        for (const eid of data.removed) {
+          if (this._entityStates.has(eid)) {
+            this._entityStates.delete(eid)
+            this._callbacks.onEntityRemoved?.(eid)
+          }
+        }
+      }
+    } else {
+      const seen = new Set()
+      for (const e of data.entities || []) {
+        const { entityId, state } = this._parseEntity(e)
+        seen.add(entityId)
+        if (!this._entityStates.has(entityId)) {
+          this._callbacks.onEntityAdded?.(entityId, state)
+        }
+        this._entityStates.set(entityId, state)
+        snapshotForBuffer.entities.push(state)
+      }
+      for (const eid of this._entityStates.keys()) {
+        if (!seen.has(eid)) {
+          this._entityStates.delete(eid)
+          this._callbacks.onEntityRemoved?.(eid)
+        }
+      }
+    }
+  }
+
+  _parsePlayer(p) {
+    if (Array.isArray(p)) {
+      return {
+        playerId: p[0],
+        state: {
+          id: p[0], position: [p[1], p[2], p[3]], rotation: [p[4], p[5], p[6], p[7]],
+          velocity: [p[8], p[9], p[10]], onGround: p[11] === 1, health: p[12],
+          inputSequence: p[13], crouch: p[14] || 0,
+          lookPitch: (p[15] || 0) / 255 * 2 * Math.PI - Math.PI,
+          lookYaw: (p[16] || 0) / 255 * 2 * Math.PI
+        }
+      }
+    }
+    return {
+      playerId: p.id || p.i,
+      state: {
+        id: p.id || p.i, position: p.position || [0, 0, 0], rotation: p.rotation || [0, 0, 0, 1],
+        velocity: p.velocity || [0, 0, 0], onGround: p.onGround ?? false, health: p.health ?? 100
+      }
+    }
+  }
+
+  _parseEntity(e) {
+    if (Array.isArray(e)) {
+      return {
+        entityId: e[0],
+        state: {
+          id: e[0], model: e[1], position: [e[2], e[3], e[4]], rotation: [e[5], e[6], e[7], e[8]],
+          bodyType: e[9], custom: e[10]
+        }
+      }
+    }
+    return {
+      entityId: e.id,
+      state: {
+        id: e.id, model: e.model, position: e.position || [0, 0, 0], rotation: e.rotation || [0, 0, 0, 1],
+        bodyType: e.bodyType || 'static', custom: e.custom || null
+      }
+    }
+  }
+
+  getPlayerState(playerId) {
+    return this._playerStates.get(playerId)
+  }
+
+  getAllPlayerStates() {
+    return new Map(this._playerStates)
+  }
+
+  getEntity(entityId) {
+    return this._entityStates.get(entityId)
+  }
+
+  getAllEntities() {
+    return new Map(this._entityStates)
+  }
+
+  removePlayer(playerId) {
+    this._playerStates.delete(playerId)
+  }
+
+  clear() {
+    this._playerStates.clear()
+    this._entityStates.clear()
+  }
+}

package/src/connection/ConnectionManager.js

@@ -31,14 +31,14 @@ export class ConnectionManager extends EventEmitter {
     })
 
     transport.on('close', () => {
-      this.removeClient(clientId)
       this.emit('disconnect', clientId, 'closed')
+      this.removeClient(clientId)
     })
 
     transport.on('error', (err) => {
       console.error(`[connection] transport error for ${clientId}:`, err.message)
-      this.removeClient(clientId)
       this.emit('disconnect', clientId, 'error')
+      this.removeClient(clientId)
     })
 
     this.clients.set(clientId, client)
@@ -52,8 +52,8 @@ export class ConnectionManager extends EventEmitter {
       if (!client) return
       const age = Date.now() - client.lastHeartbeat
       if (age > this.heartbeatTimeout) {
-        this.removeClient(clientId)
         this.emit('disconnect', clientId, 'timeout')
+        this.removeClient(clientId)
         return
       }
       const timer = setTimeout(check, this.heartbeatInterval)
@@ -63,6 +63,11 @@ export class ConnectionManager extends EventEmitter {
     this.timers.set(`hb-${clientId}`, timer)
   }
 
+  resetHeartbeat(clientId) {
+    const client = this.clients.get(clientId)
+    if (client) client.lastHeartbeat = Date.now()
+  }
+
   removeClient(clientId) {
     const client = this.clients.get(clientId)
     if (!client) return
@@ -75,6 +80,19 @@ export class ConnectionManager extends EventEmitter {
     this.timers.delete(`hb-${clientId}`)
   }
 
+  detachClient(clientId) {
+    const client = this.clients.get(clientId)
+    if (client?.transport) {
+      client.transport.removeAllListeners('message')
+      client.transport.removeAllListeners('close')
+      client.transport.removeAllListeners('error')
+    }
+    this.clients.delete(clientId)
+    const timer = this.timers.get(`hb-${clientId}`)
+    if (timer) clearTimeout(timer)
+    this.timers.delete(`hb-${clientId}`)
+  }
+
   getClient(clientId) {
     return this.clients.get(clientId)
   }