spoint 0.1.0 → 0.1.10

package/src/sdk/server.js

@@ -1,5 +1,6 @@
-import { join, dirname, resolve } from 'node:path'
+import { join, dirname, resolve, sep } from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
+import { existsSync } from 'node:fs'
 import { MSG } from '../protocol/MessageTypes.js'
 import { ConnectionManager } from '../connection/ConnectionManager.js'
 import { SessionStore } from '../connection/SessionStore.js'
@@ -24,22 +25,39 @@ import { createServerAPI } from './ServerAPI.js'
 import { createConnectionHandlers } from './ServerHandlers.js'
 
 export async function boot(overrides = {}) {
-  const ROOT = join(dirname(fileURLToPath(import.meta.url)), '../..')
-  const worldPath = resolve(ROOT, 'apps/world/index.js')
+  const SDK_ROOT = join(dirname(fileURLToPath(import.meta.url)), '../..')
+  const PROJECT = process.cwd()
+  const localWorld = resolve(PROJECT, 'apps/world/index.js')
+  const sdkWorld = resolve(SDK_ROOT, 'apps/world/index.js')
+  const worldPath = existsSync(localWorld) ? localWorld : sdkWorld
+  if (!existsSync(localWorld)) {
+    console.log('[boot] no local apps found, using bundled SDK defaults')
+  }
   const worldUrl = pathToFileURL(worldPath).href + `?t=${Date.now()}`
   const worldMod = await import(worldUrl)
   const worldDef = worldMod.default || worldMod
+  const localApps = resolve(PROJECT, 'apps')
+  const sdkApps = join(SDK_ROOT, 'apps')
+  const hasLocalApps = existsSync(localApps)
+  const appsDirs = hasLocalApps ? [localApps, sdkApps] : [sdkApps]
+  const appsStaticDirs = hasLocalApps
+    ? [{ prefix: '/apps/', dir: localApps }, { prefix: '/apps/', dir: sdkApps }]
+    : [{ prefix: '/apps/', dir: sdkApps }]
+  console.debug(`[boot] loading from: ${appsDirs.join(', ')}`)
   const config = {
-    port: parseInt(process.env.PORT || String(worldDef.port || 8080), 10),
+    port: parseInt(process.env.PORT || String(worldDef.port || 3000), 10),
     tickRate: worldDef.tickRate || 128,
-    appsDir: join(ROOT, 'apps'),
+    appsDirs,
+    sdkRoot: SDK_ROOT,
     gravity: worldDef.gravity,
     movement: worldDef.movement,
+    playerConfig: worldDef.player,
     staticDirs: [
-      { prefix: '/src/', dir: join(ROOT, 'src') },
-      { prefix: '/world/', dir: join(ROOT, 'world') },
-      { prefix: '/node_modules/', dir: join(ROOT, 'node_modules') },
-      { prefix: '/', dir: join(ROOT, 'client') }
+      { prefix: '/src/', dir: join(SDK_ROOT, 'src') },
+      ...appsStaticDirs,
+      { prefix: '/node_modules/', dir: join(SDK_ROOT, 'node_modules') },
+      { prefix: '/editor/', dir: join(SDK_ROOT, 'client/editor') },
+      { prefix: '/', dir: join(SDK_ROOT, 'client') }
     ],
     ...overrides
   }
@@ -48,42 +66,44 @@ export async function boot(overrides = {}) {
   server.on('playerJoin', ({ id }) => console.log())
   server.on('playerLeave', ({ id }) => console.log())
   const info = await server.start()
-  console.log()
+  console.log(`[server] http://localhost:${info.port} @ ${info.tickRate} TPS`)
   return server
 }
 
 export async function createServer(config = {}) {
-  const port = config.port || 8080
+  const port = config.port || 3000
   const tickRate = config.tickRate || 128
-  const appsDir = config.appsDir || './apps'
+  const appsDirs = config.appsDirs || [config.appsDir || './apps']
   const gravity = config.gravity || [0, -9.81, 0]
   const movement = config.movement || {}
   const staticDirs = config.staticDirs || []
 
   const storageDir = config.storageDir || './data'
-  const physics = new PhysicsWorld({ gravity })
+  const playerConfig = config.playerConfig || {}
+  const physics = new PhysicsWorld({ gravity, crouchHalfHeight: playerConfig.crouchHalfHeight })
   await physics.init()
 
   const emitter = new EventEmitter()
   const eventBus = new EventBus()
-  const eventLog = new EventLog()
+  const eventLog = new EventLog({ maxSize: 1000 })
   const storage = new FSAdapter(storageDir)
   const tickSystem = new TickSystem(tickRate)
   const playerManager = new PlayerManager()
   const networkState = new NetworkState()
   const lagCompensator = new LagCompensator()
-  const physicsIntegration = new PhysicsIntegration({ gravity, physicsWorld: physics })
+  const physicsIntegration = new PhysicsIntegration({ gravity, physicsWorld: physics, capsuleRadius: playerConfig.capsuleRadius, capsuleHalfHeight: playerConfig.capsuleHalfHeight, crouchHalfHeight: playerConfig.crouchHalfHeight, playerMass: playerConfig.mass })
   const connections = new ConnectionManager({
     heartbeatInterval: config.heartbeatInterval || 1000,
-    heartbeatTimeout: config.heartbeatTimeout || 3000
+    heartbeatTimeout: config.heartbeatTimeout || 10000
   })
-  const sessions = new SessionStore({ ttl: config.sessionTTL || 30000 })
+  const sessions = new SessionStore({ ttl: config.sessionTTL || 60000 })
   const inspector = new Inspector()
   const reloadManager = new ReloadManager()
 
-  const appRuntime = new AppRuntime({ gravity, playerManager, physics, physicsIntegration, connections, eventBus, eventLog, storage })
+  const sdkRoot = config.sdkRoot || join(dirname(fileURLToPath(import.meta.url)), '../..')
+  const appRuntime = new AppRuntime({ gravity, playerManager, physics, physicsIntegration, connections, eventBus, eventLog, storage, sdkRoot })
   appRuntime.setPlayerManager(playerManager)
-  const appLoader = new AppLoader(appRuntime, { dir: appsDir })
+  const appLoader = new AppLoader(appRuntime, { dirs: appsDirs })
   const stageLoader = new StageLoader(appRuntime)
   appRuntime.setStageLoader(stageLoader)
 
@@ -95,7 +115,7 @@ export async function createServer(config = {}) {
     config,
     port,
     tickRate,
-    appsDir,
+    appsDirs,
     gravity,
     movement,
     staticDirs,
@@ -127,6 +147,7 @@ export async function createServer(config = {}) {
     setTickHandler: (fn) => { ctx.handlerState.fn = fn }
   }
 
+  const worldConfigUrl = pathToFileURL(existsSync(resolve(process.cwd(), 'apps/world/index.js')) ? resolve(process.cwd(), 'apps/world/index.js') : join(dirname(fileURLToPath(import.meta.url)), '../../apps/world/index.js')).href
   const reloadHandlers = createReloadHandlers({
     networkState,
     playerManager,
@@ -134,7 +155,9 @@ export async function createServer(config = {}) {
     lagCompensator,
     physics,
     appRuntime,
-    connections
+    connections,
+    movement,
+    worldConfigPath: worldConfigUrl
   })
   ctx.reloadHandlers = reloadHandlers
 
@@ -156,23 +179,26 @@ export async function createServer(config = {}) {
 
   ctx.setupSDKWatchers = () => {
     const reloadTick = async () => { ctx.setTickHandler(await reloadHandlers.reloadTickHandler()) }
+    const sdk = (p) => join(sdkRoot, p)
     const w = [
-      ['tick-handler', './src/sdk/TickHandler.js', reloadTick],
-      ['physics-integration', './src/netcode/PhysicsIntegration.js', reloadHandlers.reloadPhysicsIntegration],
-      ['lag-compensator', './src/netcode/LagCompensator.js', reloadHandlers.reloadLagCompensator],
-      ['player-manager', './src/netcode/PlayerManager.js', reloadHandlers.reloadPlayerManager],
-      ['network-state', './src/netcode/NetworkState.js', reloadHandlers.reloadNetworkState]
+      ['tick-handler', sdk('src/sdk/TickHandler.js'), reloadTick],
+      ['movement', sdk('src/shared/movement.js'), reloadTick],
+      ['world-config', sdk('apps/world/index.js'), reloadTick],
+      ['physics-integration', sdk('src/netcode/PhysicsIntegration.js'), reloadHandlers.reloadPhysicsIntegration],
+      ['lag-compensator', sdk('src/netcode/LagCompensator.js'), reloadHandlers.reloadLagCompensator],
+      ['player-manager', sdk('src/netcode/PlayerManager.js'), reloadHandlers.reloadPlayerManager],
+      ['network-state', sdk('src/netcode/NetworkState.js'), reloadHandlers.reloadNetworkState]
     ]
     for (const [id, path, reload] of w) reloadManager.addWatcher(id, path, reload)
     const clientReload = () => { connections.broadcast(MSG.HOT_RELOAD, { timestamp: Date.now() }) }
     const clientFiles = [
-      ['client-app', './client/app.js'],
-      ['client-camera', './client/camera.js'],
-      ['client-input', './src/client/InputHandler.js'],
-      ['client-network', './src/client/PhysicsNetworkClient.js'],
-      ['client-prediction', './src/client/PredictionEngine.js'],
-      ['client-reconciliation', './src/client/ReconciliationEngine.js'],
-      ['client-index', './src/index.client.js']
+      ['client-app', sdk('client/app.js')],
+      ['client-camera', sdk('client/camera.js')],
+      ['client-input', sdk('src/client/InputHandler.js')],
+      ['client-network', sdk('src/client/PhysicsNetworkClient.js')],
+      ['client-prediction', sdk('src/client/PredictionEngine.js')],
+      ['client-reconciliation', sdk('src/client/ReconciliationEngine.js')],
+      ['client-index', sdk('src/index.client.js')]
     ]
     for (const [id, path] of clientFiles) reloadManager.addWatcher(id, path, clientReload)
   }

package/src/shared/movement.js

@@ -15,7 +15,8 @@ export function applyMovement(state, input, movement, dt) {
     const cy = Math.cos(yaw), sy = Math.sin(yaw)
     wishX = fz * sy - fx * cy
     wishZ = fx * sy + fz * cy
-    wishSpeed = flen > 0 ? maxSpeed : 0
+    const baseSpeed = input.crouch ? maxSpeed * (movement.crouchSpeedMul || 0.4) : maxSpeed
+    wishSpeed = flen > 0 ? (input.sprint && !input.crouch ? (movement.sprintSpeed || maxSpeed * 1.75) : baseSpeed) : 0
     if (input.jump && state.onGround) {
       state.velocity[1] = jumpImpulse
       state.onGround = false

package/src/spatial/Octree.js

@@ -23,6 +23,11 @@ export class SpatialIndex {
   }
 
   update(id, position) {
+    const existing = this._entities.get(id)
+    if (existing) {
+      const dx = existing[0] - position[0], dy = existing[1] - position[1], dz = existing[2] - position[2]
+      if (dx * dx + dy * dy + dz * dz < 0.001) return
+    }
     this.insert(id, position)
   }
 

package/apps/interactive-door/index.js

@@ -1,33 +0,0 @@
-export default {
-  server: {
-    setup(ctx) {
-      ctx.state.open = false
-      ctx.state.openAngle = Math.PI / 2
-      ctx.physics.setKinematic(true)
-      ctx.physics.addBoxCollider([2, 3, 0.2])
-    },
-    update(ctx, dt) {
-      const nearest = ctx.players.getNearest(ctx.entity.position, 3)
-      if (nearest && !ctx.state.open) {
-        ctx.state.open = true
-        const rot = ctx.entity.rotation
-        rot[1] = Math.sin(ctx.state.openAngle / 2)
-        rot[3] = Math.cos(ctx.state.openAngle / 2)
-        ctx.entity.rotation = rot
-      } else if (!nearest && ctx.state.open) {
-        ctx.state.open = false
-        ctx.entity.rotation = [0, 0, 0, 1]
-      }
-    }
-  },
-  client: {
-    render(ctx) {
-      return {
-        model: ctx.entity.model,
-        position: ctx.entity.position,
-        rotation: ctx.entity.rotation,
-        custom: { doorOpen: ctx.state.open }
-      }
-    }
-  }
-}

package/apps/patrol-npc/index.js

@@ -1,37 +0,0 @@
-export default {
-  server: {
-    setup(ctx) {
-      ctx.state.waypoints = [[0, 0, 0], [10, 0, 0], [10, 0, 10], [0, 0, 10]]
-      ctx.state.current = 0
-      ctx.state.speed = 3
-      ctx.physics.setKinematic(true)
-      ctx.physics.addCapsuleCollider(0.5, 1.8)
-    },
-    update(ctx, dt) {
-      const target = ctx.state.waypoints[ctx.state.current]
-      const pos = ctx.entity.position
-      const dx = target[0] - pos[0]
-      const dz = target[2] - pos[2]
-      const dist = Math.sqrt(dx * dx + dz * dz)
-      if (dist < 0.5) {
-        ctx.state.current = (ctx.state.current + 1) % ctx.state.waypoints.length
-      } else {
-        const step = ctx.state.speed * dt
-        pos[0] += (dx / dist) * step
-        pos[2] += (dz / dist) * step
-        const angle = Math.atan2(dx, dz)
-        ctx.entity.rotation = [0, Math.sin(angle / 2), 0, Math.cos(angle / 2)]
-      }
-    }
-  },
-  client: {
-    render(ctx) {
-      return {
-        model: ctx.entity.model,
-        position: ctx.entity.position,
-        rotation: ctx.entity.rotation,
-        custom: { animation: 'walk' }
-      }
-    }
-  }
-}

package/src/connection/QualityMonitor.js

@@ -1,46 +0,0 @@
-export class QualityMonitor {
-  constructor() {
-    this.bytesIn = 0
-    this.bytesOut = 0
-    this.heartbeatsSent = 0
-    this.heartbeatsReceived = 0
-    this.rttSamples = []
-    this.startTime = Date.now()
-  }
-
-  recordBytesIn(count) {
-    this.bytesIn += count
-  }
-
-  recordBytesOut(count) {
-    this.bytesOut += count
-  }
-
-  recordHeartbeatSent() {
-    this.heartbeatsSent++
-  }
-
-  recordHeartbeatReceived() {
-    this.heartbeatsReceived++
-  }
-
-  recordRtt(rtt) {
-    this.rttSamples.push(rtt)
-    if (this.rttSamples.length > 100) this.rttSamples.shift()
-  }
-
-  getStats() {
-    const elapsed = Date.now() - this.startTime
-    const avgRtt = this.rttSamples.length > 0
-      ? this.rttSamples.reduce((a, b) => a + b, 0) / this.rttSamples.length
-      : 0
-    return {
-      bytesIn: this.bytesIn,
-      bytesOut: this.bytesOut,
-      heartbeatsSent: this.heartbeatsSent,
-      heartbeatsReceived: this.heartbeatsReceived,
-      avgRtt,
-      uptime: elapsed
-    }
-  }
-}

package/src/debug/StateInspector.js

@@ -1,42 +0,0 @@
-export class StateInspector {
-  constructor() {
-    this.snapshots = []
-    this.delays = []
-    this.corrections = []
-    this.maxSnapshots = 100
-  }
-
-  recordSnapshot(snap) {
-    this.snapshots.push({ ...snap, timestamp: Date.now() })
-    if (this.snapshots.length > this.maxSnapshots) {
-      this.snapshots.shift()
-    }
-  }
-
-  recordSnapshotDelay(delay) {
-    this.delays.push(delay)
-    if (this.delays.length > this.maxSnapshots) {
-      this.delays.shift()
-    }
-  }
-
-  recordCorrection(playerId, oldState, newState, deviationMs) {
-    this.corrections.push({ playerId, newState, deviationMs, timestamp: Date.now() })
-    if (this.corrections.length > this.maxSnapshots) {
-      this.corrections.shift()
-    }
-  }
-
-  getStats() {
-    const avgDelay = this.delays.length > 0
-      ? this.delays.reduce((a, b) => a + b, 0) / this.delays.length
-      : 0
-    return {
-      snapshots: this.snapshots.length,
-      delays: this.delays.length,
-      avgDelay,
-      corrections: this.corrections.length,
-      lastSnapshot: this.snapshots[this.snapshots.length - 1] || null
-    }
-  }
-}

package/src/index.js

@@ -1 +0,0 @@
-export * from './index.server.js'

package/src/index.server.js

@@ -1,27 +0,0 @@
-export { PhysicsWorld } from './physics/World.js'
-
-export { AppRuntime } from './apps/AppRuntime.js'
-export { EventBus } from './apps/EventBus.js'
-export { StageLoader } from './stage/StageLoader.js'
-export { Stage } from './stage/Stage.js'
-export { SpatialIndex } from './spatial/Octree.js'
-
-export { TickSystem } from './netcode/TickSystem.js'
-export { NetworkState } from './netcode/NetworkState.js'
-export { SnapshotEncoder } from './netcode/SnapshotEncoder.js'
-export { PlayerManager } from './netcode/PlayerManager.js'
-export { LagCompensator } from './netcode/LagCompensator.js'
-export { PhysicsIntegration } from './netcode/PhysicsIntegration.js'
-export { EventLog } from './netcode/EventLog.js'
-
-export { StorageAdapter } from './storage/StorageAdapter.js'
-export { FSAdapter } from './storage/FSAdapter.js'
-
-export { MSG, msgName, DISCONNECT_REASONS, CONNECTION_QUALITY, UNRELIABLE_MSGS, isUnreliable } from './protocol/MessageTypes.js'
-export { Codec } from './protocol/Codec.js'
-export { SequenceTracker } from './protocol/SequenceTracker.js'
-
-export { TransportWrapper } from './transport/TransportWrapper.js'
-export { WebSocketTransport } from './transport/WebSocketTransport.js'
-export { WebTransportTransport } from './transport/WebTransportTransport.js'
-export { WebTransportServer, WEBTRANSPORT_AVAILABLE } from './transport/WebTransportServer.js'

package/src/protocol/Codec.js

@@ -1,60 +0,0 @@
-import { pack, unpack } from './msgpack.js'
-
-function toUint8(input) {
-  if (input instanceof Uint8Array) return input
-  if (input instanceof ArrayBuffer) return new Uint8Array(input)
-  if (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength)
-  return new Uint8Array(input)
-}
-
-export class Codec {
-  constructor() {
-    this.bytesSent = 0
-    this.bytesReceived = 0
-    this.messagesSent = 0
-    this.messagesReceived = 0
-    this.sendSequence = 0
-  }
-
-  encode(type, payload) {
-    const seq = this.sendSequence++ & 0xFFFF
-    const body = pack(payload)
-    const bodyBytes = toUint8(body)
-    const frame = new Uint8Array(3 + bodyBytes.length)
-    frame[0] = type
-    frame[1] = (seq >> 8) & 0xFF
-    frame[2] = seq & 0xFF
-    frame.set(bodyBytes, 3)
-    this.bytesSent += frame.length
-    this.messagesSent++
-    return frame
-  }
-
-  decode(buffer) {
-    const buf = toUint8(buffer)
-    if (buf.length < 3) return null
-    const type = buf[0]
-    const seq = (buf[1] << 8) | buf[2]
-    const payload = buf.length > 3 ? unpack(buf.slice(3)) : null
-    this.bytesReceived += buf.length
-    this.messagesReceived++
-    return { type, seq, payload }
-  }
-
-  getStats() {
-    return {
-      bytesSent: this.bytesSent,
-      bytesReceived: this.bytesReceived,
-      messagesSent: this.messagesSent,
-      messagesReceived: this.messagesReceived,
-      sendSequence: this.sendSequence
-    }
-  }
-
-  resetStats() {
-    this.bytesSent = 0
-    this.bytesReceived = 0
-    this.messagesSent = 0
-    this.messagesReceived = 0
-  }
-}

package/src/protocol/SequenceTracker.js

@@ -1,71 +0,0 @@
-export class SequenceTracker {
-  constructor(windowSize = 256) {
-    this.windowSize = windowSize
-    this.nextExpected = 0
-    this.received = new Set()
-    this.outOfOrder = []
-    this.totalReceived = 0
-    this.totalExpected = 0
-    this.gaps = 0
-  }
-
-  track(seq) {
-    this.totalReceived++
-    if (seq === this.nextExpected) {
-      this.nextExpected = (this.nextExpected + 1) & 0xFFFF
-      this._drainOutOfOrder()
-      return { inOrder: true, gap: 0 }
-    }
-    const gap = (seq - this.nextExpected + 0x10000) & 0xFFFF
-    if (gap > this.windowSize) {
-      this.nextExpected = (seq + 1) & 0xFFFF
-      this.outOfOrder = []
-      this.received.clear()
-      return { inOrder: true, gap: 0, reset: true }
-    }
-    this.gaps++
-    this.outOfOrder.push(seq)
-    this.outOfOrder.sort((a, b) => {
-      const da = (a - this.nextExpected + 0x10000) & 0xFFFF
-      const db = (b - this.nextExpected + 0x10000) & 0xFFFF
-      return da - db
-    })
-    this.received.add(seq)
-    return { inOrder: false, gap }
-  }
-
-  _drainOutOfOrder() {
-    while (this.outOfOrder.length > 0 && this.outOfOrder[0] === this.nextExpected) {
-      this.outOfOrder.shift()
-      this.received.delete(this.nextExpected)
-      this.nextExpected = (this.nextExpected + 1) & 0xFFFF
-    }
-  }
-
-  getPacketLoss() {
-    if (this.totalReceived === 0) return 0
-    const expected = this.nextExpected
-    if (expected === 0) return 0
-    const lost = expected - this.totalReceived
-    return Math.max(0, lost / expected)
-  }
-
-  getStats() {
-    return {
-      nextExpected: this.nextExpected,
-      totalReceived: this.totalReceived,
-      outOfOrderCount: this.outOfOrder.length,
-      gapEvents: this.gaps,
-      packetLoss: this.getPacketLoss()
-    }
-  }
-
-  reset() {
-    this.nextExpected = 0
-    this.received.clear()
-    this.outOfOrder = []
-    this.totalReceived = 0
-    this.totalExpected = 0
-    this.gaps = 0
-  }
-}

package/src/sdk/ClientMessageHandler.js

@@ -1,80 +0,0 @@
-import { MSG } from '../protocol/MessageTypes.js'
-import { SnapshotEncoder } from '../netcode/SnapshotEncoder.js'
-import { unpack } from '../protocol/msgpack.js'
-
-export function createMessageRouter(deps) {
-  const { emitter, quality, stateInspector, send, getState, setState } = deps
-
-  function handleSnapshot(data) {
-    try {
-      const decoded = SnapshotEncoder.decode(data)
-      if (decoded.tick) {
-        stateInspector.recordSnapshotDelay(Date.now() - (decoded.timestamp || 0))
-        setState('tick', decoded.tick)
-      }
-      for (const p of decoded.players || []) getState('players').set(p.id, p)
-      for (const e of decoded.entities || []) getState('entities').set(e.id, e)
-      emitter.emit('snapshot', decoded)
-    } catch (e) {
-      emitter.emit('error', e)
-    }
-  }
-
-  return function onMessage(raw) {
-    const buf = raw instanceof ArrayBuffer ? new Uint8Array(raw) : (raw instanceof Uint8Array ? raw : new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength))
-    let msg
-    try { msg = unpack(buf) } catch (e) { return }
-    if (!msg || typeof msg !== 'object') return
-    const byteLen = buf.length || buf.byteLength || 0
-    quality.recordBytesIn(byteLen)
-
-    if (msg.type === MSG.HEARTBEAT) {
-      send(MSG.HEARTBEAT_ACK, { ts: msg.payload?.ts })
-      return
-    }
-    if (msg.type === MSG.HEARTBEAT_ACK && msg.payload?.ts) {
-      quality.recordRtt(Date.now() - msg.payload.ts)
-      quality.recordHeartbeatReceived()
-      return
-    }
-    if (msg.type === MSG.HANDSHAKE_ACK) {
-      setState('playerId', msg.payload.playerId)
-      setState('sessionToken', msg.payload.sessionToken)
-      setState('tick', msg.payload.tick)
-      emitter.emit('connect', { playerId: msg.payload.playerId, tick: msg.payload.tick })
-      return
-    }
-    if (msg.type === MSG.SNAPSHOT) { handleSnapshot(msg.payload); return }
-    if (msg.type === MSG.PLAYER_LEAVE) {
-      getState('players').delete(msg.payload.playerId)
-      emitter.emit('playerLeave', msg.payload.playerId)
-      return
-    }
-    if (msg.type === MSG.RECONNECT_ACK) {
-      setState('playerId', msg.payload.playerId)
-      setState('sessionToken', msg.payload.sessionToken)
-      setState('tick', msg.payload.tick)
-      setState('reconnecting', false)
-      setState('reconnectAttempts', 0)
-      emitter.emit('reconnect', msg.payload)
-      return
-    }
-    if (msg.type === MSG.STATE_RECOVERY) {
-      const decoded = SnapshotEncoder.decode(msg.payload.snapshot)
-      for (const p of decoded.players || []) getState('players').set(p.id, p)
-      for (const e of decoded.entities || []) getState('entities').set(e.id, e)
-      emitter.emit('stateRecovery', decoded)
-      return
-    }
-    if (msg.type === MSG.STATE_CORRECTION) {
-      stateInspector.recordCorrection(getState('playerId'), null, msg.payload, 0)
-      emitter.emit('correction', msg.payload)
-      return
-    }
-    if (msg.type === MSG.DISCONNECT_REASON) {
-      emitter.emit('disconnectReason', msg.payload)
-      return
-    }
-    emitter.emit('message', msg)
-  }
-}