spoint 0.1.0 → 0.1.10

package/src/protocol/msgpack.js

@@ -1,74 +1,101 @@
 const encoder = new TextEncoder()
 const decoder = new TextDecoder()
+const f64Buf = new ArrayBuffer(8)
+const f64View = new DataView(f64Buf)
+const f64Bytes = new Uint8Array(f64Buf)
 
-export function pack(value) {
-  const chunks = []
-  function write(value) {
-    if (value === null || value === undefined) {
-      chunks.push(0xc0)
-    } else if (value === false) {
-      chunks.push(0xc2)
-    } else if (value === true) {
-      chunks.push(0xc3)
-    } else if (typeof value === 'number') {
-      if (Number.isInteger(value)) {
-        if (value >= 0) {
-          if (value < 128) chunks.push(value)
-          else if (value < 256) chunks.push(0xcc, value)
-          else if (value < 65536) chunks.push(0xcd, value >> 8, value & 0xff)
-          else if (value < 4294967296) chunks.push(0xce, (value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff)
-          else writeFloat64(value)
-        } else {
-          if (value >= -32) chunks.push(value & 0xff)
-          else if (value >= -128) chunks.push(0xd0, value & 0xff)
-          else if (value >= -32768) chunks.push(0xd1, (value >> 8) & 0xff, value & 0xff)
-          else if (value >= -2147483648) chunks.push(0xd2, (value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff)
-          else writeFloat64(value)
-        }
+let buf = new Uint8Array(4096)
+let pos = 0
+
+function grow(need) {
+  if (pos + need <= buf.length) return
+  let size = buf.length
+  while (size < pos + need) size *= 2
+  const next = new Uint8Array(size)
+  next.set(buf.subarray(0, pos))
+  buf = next
+}
+
+function w1(v) { grow(1); buf[pos++] = v }
+function w2(a, b) { grow(2); buf[pos++] = a; buf[pos++] = b }
+function w3(a, b, c) { grow(3); buf[pos++] = a; buf[pos++] = b; buf[pos++] = c }
+function w5(a, b, c, d, e) { grow(5); buf[pos++] = a; buf[pos++] = b; buf[pos++] = c; buf[pos++] = d; buf[pos++] = e }
+
+function writeFloat64(value) {
+  grow(9)
+  buf[pos++] = 0xcb
+  f64View.setFloat64(0, value, false)
+  buf[pos++] = f64Bytes[0]; buf[pos++] = f64Bytes[1]; buf[pos++] = f64Bytes[2]; buf[pos++] = f64Bytes[3]
+  buf[pos++] = f64Bytes[4]; buf[pos++] = f64Bytes[5]; buf[pos++] = f64Bytes[6]; buf[pos++] = f64Bytes[7]
+}
+
+function write(value) {
+  if (value === null || value === undefined) {
+    w1(0xc0)
+  } else if (value === false) {
+    w1(0xc2)
+  } else if (value === true) {
+    w1(0xc3)
+  } else if (typeof value === 'number') {
+    if (Number.isInteger(value)) {
+      if (value >= 0) {
+        if (value < 128) w1(value)
+        else if (value < 256) w2(0xcc, value)
+        else if (value < 65536) w3(0xcd, value >> 8, value & 0xff)
+        else if (value < 4294967296) w5(0xce, (value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff)
+        else writeFloat64(value)
       } else {
-        writeFloat64(value)
+        if (value >= -32) w1(value & 0xff)
+        else if (value >= -128) w2(0xd0, value & 0xff)
+        else if (value >= -32768) w3(0xd1, (value >> 8) & 0xff, value & 0xff)
+        else if (value >= -2147483648) w5(0xd2, (value >> 24) & 0xff, (value >> 16) & 0xff, (value >> 8) & 0xff, value & 0xff)
+        else writeFloat64(value)
       }
-    } else if (typeof value === 'string') {
-      const bytes = encoder.encode(value)
-      const len = bytes.length
-      if (len < 32) chunks.push(0xa0 | len)
-      else if (len < 256) chunks.push(0xd9, len)
-      else if (len < 65536) chunks.push(0xda, len >> 8, len & 0xff)
-      else chunks.push(0xdb, (len >> 24) & 0xff, (len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff)
-      for (let i = 0; i < len; i++) chunks.push(bytes[i])
-    } else if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
-      const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value
-      const len = bytes.length
-      if (len < 256) chunks.push(0xc4, len)
-      else if (len < 65536) chunks.push(0xc5, len >> 8, len & 0xff)
-      else chunks.push(0xc6, (len >> 24) & 0xff, (len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff)
-      for (let i = 0; i < len; i++) chunks.push(bytes[i])
-    } else if (Array.isArray(value)) {
-      const len = value.length
-      if (len < 16) chunks.push(0x90 | len)
-      else if (len < 65536) chunks.push(0xdc, len >> 8, len & 0xff)
-      else chunks.push(0xdd, (len >> 24) & 0xff, (len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff)
-      for (let i = 0; i < len; i++) write(value[i])
-    } else if (typeof value === 'object') {
-      const keys = Object.keys(value)
-      const len = keys.length
-      if (len < 16) chunks.push(0x80 | len)
-      else if (len < 65536) chunks.push(0xde, len >> 8, len & 0xff)
-      else chunks.push(0xdf, (len >> 24) & 0xff, (len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff)
-      for (const key of keys) { write(key); write(value[key]) }
+    } else {
+      writeFloat64(value)
     }
+  } else if (typeof value === 'string') {
+    const bytes = encoder.encode(value)
+    const len = bytes.length
+    if (len < 32) w1(0xa0 | len)
+    else if (len < 256) w2(0xd9, len)
+    else if (len < 65536) w3(0xda, len >> 8, len & 0xff)
+    else w5(0xdb, (len >> 24) & 0xff, (len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff)
+    grow(len)
+    buf.set(bytes, pos)
+    pos += len
+  } else if (value instanceof Uint8Array || value instanceof ArrayBuffer) {
+    const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : value
+    const len = bytes.length
+    if (len < 256) w2(0xc4, len)
+    else if (len < 65536) w3(0xc5, len >> 8, len & 0xff)
+    else w5(0xc6, (len >> 24) & 0xff, (len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff)
+    grow(len)
+    buf.set(bytes, pos)
+    pos += len
+  } else if (Array.isArray(value)) {
+    const len = value.length
+    if (len < 16) w1(0x90 | len)
+    else if (len < 65536) w3(0xdc, len >> 8, len & 0xff)
+    else w5(0xdd, (len >> 24) & 0xff, (len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff)
+    for (let i = 0; i < len; i++) write(value[i])
+  } else if (typeof value === 'object') {
+    const keys = Object.keys(value)
+    const len = keys.length
+    if (len < 16) w1(0x80 | len)
+    else if (len < 65536) w3(0xde, len >> 8, len & 0xff)
+    else w5(0xdf, (len >> 24) & 0xff, (len >> 16) & 0xff, (len >> 8) & 0xff, len & 0xff)
+    for (const key of keys) { write(key); write(value[key]) }
   }
-  function writeFloat64(value) {
-    chunks.push(0xcb)
-    const buf = new ArrayBuffer(8)
-    new DataView(buf).setFloat64(0, value, false)
-    const bytes = new Uint8Array(buf)
-    for (let i = 0; i < 8; i++) chunks.push(bytes[i])
-  }
+}
+
+export function pack(value) {
+  pos = 0
   write(value)
-  return new Uint8Array(chunks)
+  return buf.slice(0, pos)
 }
 
+
 export function unpack(buffer) {
   const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer)
   let offset = 0
@@ -109,8 +136,8 @@ export function unpack(buffer) {
   function readInt8() { const v = bytes[offset++]; return v > 127 ? v - 256 : v }
   function readInt16() { const v = (bytes[offset] << 8) | bytes[offset + 1]; offset += 2; return v > 32767 ? v - 65536 : v }
   function readInt32() { const v = (bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]; offset += 4; return v }
-  function readFloat32() { const buf = new ArrayBuffer(4); const view = new Uint8Array(buf); for (let i = 0; i < 4; i++) view[i] = bytes[offset++]; return new DataView(buf).getFloat32(0, false) }
-  function readFloat64() { const buf = new ArrayBuffer(8); const view = new Uint8Array(buf); for (let i = 0; i < 8; i++) view[i] = bytes[offset++]; return new DataView(buf).getFloat64(0, false) }
+  function readFloat32() { const b = new ArrayBuffer(4); const v = new Uint8Array(b); for (let i = 0; i < 4; i++) v[i] = bytes[offset++]; return new DataView(b).getFloat32(0, false) }
+  function readFloat64() { const b = new ArrayBuffer(8); const v = new Uint8Array(b); for (let i = 0; i < 8; i++) v[i] = bytes[offset++]; return new DataView(b).getFloat64(0, false) }
   function readString(len) { const slice = bytes.subarray(offset, offset + len); offset += len; return decoder.decode(slice) }
   function readBin(len) { const slice = bytes.slice(offset, offset + len); offset += len; return slice }
   function readArray(len) { const arr = new Array(len); for (let i = 0; i < len; i++) arr[i] = read(); return arr }

package/src/sdk/ReloadHandlers.js

@@ -34,8 +34,18 @@ export function createReloadHandlers(deps) {
   } = deps
 
   const reloadTickHandler = async () => {
-    const { createTickHandler: refreshHandler } = await import('./TickHandler.js?' + Date.now())
-    return refreshHandler(deps)
+    const t = Date.now()
+    const { applyMovement, DEFAULT_MOVEMENT } = await import('../shared/movement.js?' + t)
+    const { createTickHandler: refreshHandler } = await import('./TickHandler.js?' + t)
+    let movement = deps.movement
+    if (deps.worldConfigPath) {
+      try {
+        const wm = await import(deps.worldConfigPath + '?' + t)
+        const wd = wm.default || wm
+        if (wd.movement) movement = wd.movement
+      } catch (e) {}
+    }
+    return refreshHandler({ ...deps, movement, _movement: { applyMovement, DEFAULT_MOVEMENT } })
   }
 
   const reloadPhysicsIntegration = async () => {

package/src/sdk/ReloadManager.js

@@ -1,4 +1,5 @@
 import { watch } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 
 export class ReloadManager {
@@ -16,6 +17,10 @@ export class ReloadManager {
   addWatcher(moduleId, filePath, onReload, validator) {
     const absPath = resolve(filePath)
     if (this._watchers.has(moduleId)) return
+    if (!existsSync(absPath)) {
+      console.debug(`[ReloadManager] skipping watch for missing file: ${moduleId}`)
+      return
+    }
     this._reloadState.set(moduleId, { inProgress: false, lastSuccess: null, failureCount: 0 })
     this._failureCounters.set(moduleId, 0)
     if (validator) this._validators.set(moduleId, validator)

package/src/sdk/ServerHandlers.js

@@ -6,9 +6,10 @@ export function createConnectionHandlers(ctx) {
 
   function onClientConnect(transport) {
     const sp = [...ctx.worldSpawnPoint]
-    const playerId = playerManager.addPlayer(transport, { position: sp })
+    const playerConfig = ctx.currentWorldDef?.player || {}
+    const playerId = playerManager.addPlayer(transport, { position: sp, health: playerConfig.health })
     networkState.addPlayer(playerId, { position: sp })
-    physicsIntegration.addPlayerCollider(playerId, 0.4)
+    physicsIntegration.addPlayerCollider(playerId, playerConfig.capsuleRadius || 0.4)
     physicsIntegration.setPlayerPosition(playerId, sp)
     const playerState = playerManager.getPlayer(playerId).state
     lagCompensator.recordPlayerPosition(playerId, playerState.position, playerState.rotation, playerState.velocity, tickSystem.currentTick)
@@ -24,23 +25,25 @@ export function createConnectionHandlers(ctx) {
     }
     const snap = appRuntime.getSnapshot()
     connections.send(playerId, MSG.SNAPSHOT, { seq: ++ctx.snapshotSeq, ...SnapshotEncoder.encode(snap) })
-    appRuntime.fireMessage('game', { type: 'player_join', playerId })
+    for (const [entityId] of appRuntime.apps) appRuntime.fireMessage(entityId, { type: 'player_join', playerId })
     emitter.emit('playerJoin', { id: playerId })
   }
 
   connections.on('message', (clientId, msg) => {
     if (inspector.handleMessage(clientId, msg)) return
+    if (msg.type === MSG.HEARTBEAT) {
+      connections.send(clientId, MSG.HEARTBEAT_ACK, { timestamp: msg.payload?.timestamp || Date.now() })
+      return
+    }
     if (msg.type === MSG.INPUT || msg.type === MSG.PLAYER_INPUT) {
       playerManager.addInput(clientId, msg.payload?.input || msg.payload)
       return
     }
     if (msg.type === MSG.APP_EVENT) {
       if (msg.payload?.entityId) appRuntime.fireInteract(msg.payload.entityId, { id: clientId })
-      if (msg.payload?.type === 'fire') {
-        const shooter = playerManager.getPlayer(clientId)
-        const pos = shooter?.state?.position || [0, 0, 0]
-        const origin = [pos[0], pos[1] + 0.9, pos[2]]
-        appRuntime.fireMessage('game', { ...msg.payload, shooterId: clientId, origin })
+      const eventData = { ...msg.payload, senderId: clientId }
+      for (const [entityId] of appRuntime.apps) {
+        appRuntime.fireMessage(entityId, eventData)
       }
       return
     }
@@ -50,10 +53,46 @@ export function createConnectionHandlers(ctx) {
         connections.send(clientId, MSG.DISCONNECT_REASON, { code: DISCONNECT_REASONS.INVALID_SESSION })
         return
       }
+      const oldId = session.playerId
+      const savedState = session.state || {}
+      const client = connections.getClient(clientId)
+      const transport = client?.transport
+      if (!transport) return
+      const playerConfig = ctx.currentWorldDef?.player || {}
+      const sp = savedState.position || [...ctx.worldSpawnPoint]
+      if (playerManager.getPlayer(oldId)) {
+        playerManager.removePlayer(oldId)
+        networkState.removePlayer(oldId)
+        physicsIntegration.removePlayerCollider(oldId)
+        lagCompensator.clearPlayerHistory(oldId)
+        connections.broadcast(MSG.PLAYER_LEAVE, { playerId: oldId })
+      }
+      if (clientId !== oldId && playerManager.getPlayer(clientId)) {
+        playerManager.removePlayer(clientId)
+        networkState.removePlayer(clientId)
+        physicsIntegration.removePlayerCollider(clientId)
+        lagCompensator.clearPlayerHistory(clientId)
+        connections.broadcast(MSG.PLAYER_LEAVE, { playerId: clientId })
+      }
+      connections.detachClient(clientId)
+      const newId = playerManager.addPlayer(transport, { position: sp, health: savedState.health ?? playerConfig.health ?? 100, velocity: savedState.velocity, rotation: savedState.rotation })
+      networkState.addPlayer(newId, { position: sp })
+      physicsIntegration.addPlayerCollider(newId, playerConfig.capsuleRadius || 0.4)
+      physicsIntegration.setPlayerPosition(newId, sp)
+      const reconnClient = connections.addClient(newId, transport)
+      reconnClient.sessionToken = msg.payload.sessionToken
+      sessions.update(msg.payload.sessionToken, { state: playerManager.getPlayer(newId).state })
+      connections.send(newId, MSG.RECONNECT_ACK, { playerId: newId, tick: tickSystem.currentTick, sessionToken: msg.payload.sessionToken })
+      if (ctx.currentWorldDef) connections.send(newId, MSG.WORLD_DEF, ctx.currentWorldDef)
+      const clientModules = appLoader.getClientModules()
+      for (const [appName, code] of Object.entries(clientModules)) {
+        connections.send(newId, MSG.APP_MODULE, { app: appName, code })
+      }
       const snap = networkState.getSnapshot()
       const ents = appRuntime.getSnapshot()
-      connections.send(clientId, MSG.RECONNECT_ACK, { playerId: session.playerId, tick: tickSystem.currentTick, sessionToken: msg.payload.sessionToken })
-      connections.send(clientId, MSG.STATE_RECOVERY, { snapshot: SnapshotEncoder.encode({ tick: snap.tick, timestamp: snap.timestamp, players: snap.players, entities: ents.entities }), tick: tickSystem.currentTick })
+      connections.send(newId, MSG.STATE_RECOVERY, { snapshot: SnapshotEncoder.encode({ tick: snap.tick, timestamp: snap.timestamp, players: snap.players, entities: ents.entities }), tick: tickSystem.currentTick })
+      for (const [entityId] of appRuntime.apps) appRuntime.fireMessage(entityId, { type: 'player_join', playerId: newId })
+      emitter.emit('playerJoin', { id: newId, reconnected: true })
       return
     }
     emitter.emit('message', clientId, msg)
@@ -62,7 +101,7 @@ export function createConnectionHandlers(ctx) {
   connections.on('disconnect', (clientId, reason) => {
     const client = connections.getClient(clientId)
     if (client?.sessionToken) { const p = playerManager.getPlayer(clientId); if (p) sessions.update(client.sessionToken, { state: p.state }) }
-    appRuntime.fireMessage('game', { type: 'player_leave', playerId: clientId })
+    for (const [entityId] of appRuntime.apps) appRuntime.fireMessage(entityId, { type: 'player_leave', playerId: clientId })
     physicsIntegration.removePlayerCollider(clientId)
     lagCompensator.clearPlayerHistory(clientId)
     inspector.removeClient(clientId)

package/src/sdk/StaticHandler.js

@@ -1,32 +1,48 @@
-import { readFileSync, existsSync } from 'node:fs'
+import { readFileSync, existsSync, statSync } from 'node:fs'
 import { join, extname } from 'node:path'
+import { gzipSync } from 'node:zlib'
 
 const MIME_TYPES = {
   '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css',
-  '.json': 'application/json', '.glb': 'model/gltf-binary', '.gltf': 'model/gltf+json',
+  '.json': 'application/json', '.glb': 'model/gltf-binary', '.gltf': 'model/gltf+json', '.vrm': 'model/gltf-binary',
   '.png': 'image/png', '.jpg': 'image/jpeg', '.webp': 'image/webp',
-  '.svg': 'image/svg+xml', '.wasm': 'application/wasm'
+  '.svg': 'image/svg+xml', '.wasm': 'application/wasm', '.ico': 'image/x-icon'
 }
 
+const GZIP_EXTENSIONS = new Set(['.glb', '.vrm', '.gltf', '.js', '.css', '.html', '.json'])
+
 export function createStaticHandler(dirs) {
   return (req, res) => {
     const url = req.url.split('?')[0]
+    if (url === '/favicon.ico') {
+      res.writeHead(204)
+      res.end()
+      return
+    }
     for (const { prefix, dir } of dirs) {
       if (!url.startsWith(prefix)) continue
       const relative = url === prefix ? '/index.html' : url.slice(prefix.length)
       const fp = join(dir, relative)
-      if (existsSync(fp)) {
+      if (existsSync(fp) && statSync(fp).isFile()) {
         const ext = extname(fp)
         const headers = { 'Content-Type': MIME_TYPES[ext] || 'application/octet-stream' }
         if (ext === '.js' || ext === '.html' || ext === '.css') {
           headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
+        } else if (ext === '.glb' || ext === '.vrm' || ext === '.gltf') {
+          headers['Cache-Control'] = 'public, max-age=86400, immutable'
+        }
+        let content = readFileSync(fp)
+        if (GZIP_EXTENSIONS.has(ext) && content.length > 100) {
+          content = gzipSync(content)
+          headers['Content-Encoding'] = 'gzip'
         }
+        headers['Content-Length'] = content.length
         res.writeHead(200, headers)
-        res.end(readFileSync(fp))
+        res.end(content)
         return
       }
     }
-    res.writeHead(404)
+    res.writeHead(404, { 'Cache-Control': 'no-store' })
     res.end('not found')
   }
 }

package/src/sdk/TickHandler.js

@@ -1,84 +1,151 @@
 import { MSG } from '../protocol/MessageTypes.js'
 import { SnapshotEncoder } from '../netcode/SnapshotEncoder.js'
-import { applyMovement, DEFAULT_MOVEMENT } from '../shared/movement.js'
+import { applyMovement as _applyMovement, DEFAULT_MOVEMENT as _DEFAULT_MOVEMENT } from '../shared/movement.js'
+
+const KEYFRAME_INTERVAL = 128
 
 export function createTickHandler(deps) {
   const {
     networkState, playerManager, physicsIntegration,
     lagCompensator, physics, appRuntime, connections,
-    movement: m = {}, stageLoader, eventLog
+    movement: m = {}, stageLoader, eventLog, _movement
   } = deps
+  const applyMovement = _movement?.applyMovement || _applyMovement
+  const DEFAULT_MOVEMENT = _movement?.DEFAULT_MOVEMENT || _DEFAULT_MOVEMENT
   const movement = { ...DEFAULT_MOVEMENT, ...m }
-  const collisionRestitution = m.collisionRestitution || 0.2
-  const collisionDamping = m.collisionDamping || 0.25
+  const collisionRestitution = movement.collisionRestitution || 0.2
+  const collisionDamping = movement.collisionDamping || 0.25
   let snapshotSeq = 0
 
+  const playerEntityMaps = new Map()
+  let broadcastEntityMap = new Map()
+
+  let profileLog = 0
+  const separated = new Set()
   return function onTick(tick, dt) {
+    const t0 = performance.now()
     networkState.setTick(tick, Date.now())
-    for (const player of playerManager.getConnectedPlayers()) {
+    const players = playerManager.getConnectedPlayers()
+    for (const player of players) {
       const inputs = playerManager.getInputs(player.id)
       const st = player.state
-      let inp = null
 
       if (inputs.length > 0) {
-        inp = inputs[inputs.length - 1].data
-        if (inp) {
-          const yaw = inp.yaw || 0
-          st.rotation = [0, Math.sin(yaw / 2), 0, Math.cos(yaw / 2)]
-        }
+        player.lastInput = inputs[inputs.length - 1].data
         playerManager.clearInputs(player.id)
       }
+      const inp = player.lastInput || null
+      if (inp) {
+        const yaw = inp.yaw || 0
+        st.rotation = [0, Math.sin(yaw / 2), 0, Math.cos(yaw / 2)]
+        st.crouch = inp.crouch ? 1 : 0
+        st.lookPitch = inp.pitch || 0
+        st.lookYaw = yaw
+      }
 
       applyMovement(st, inp, movement, dt)
+      if (inp) physicsIntegration.setCrouch(player.id, !!inp.crouch)
+      const wishedVx = st.velocity[0], wishedVz = st.velocity[2]
       const updated = physicsIntegration.updatePlayerPhysics(player.id, st, dt)
       st.position = updated.position
       st.velocity = updated.velocity
+      st.velocity[0] = wishedVx
+      st.velocity[2] = wishedVz
       st.onGround = updated.onGround
       lagCompensator.recordPlayerPosition(player.id, st.position, st.rotation, st.velocity, tick)
       networkState.updatePlayer(player.id, {
         position: st.position, rotation: st.rotation,
         velocity: st.velocity, onGround: st.onGround,
-        health: st.health, inputSequence: player.inputSequence
+        health: st.health, inputSequence: player.inputSequence,
+        crouch: st.crouch || 0, lookPitch: st.lookPitch || 0, lookYaw: st.lookYaw || 0
       })
     }
-    const players = playerManager.getConnectedPlayers()
+    const t1 = performance.now()
+    separated.clear()
     for (const player of players) {
       const collisions = physicsIntegration.checkCollisionWithOthers(player.id, players)
       for (const collision of collisions) {
+        const pairKey = player.id < collision.playerId ? `${player.id}-${collision.playerId}` : `${collision.playerId}-${player.id}`
+        if (separated.has(pairKey)) continue
+        separated.add(pairKey)
         const other = playerManager.getPlayer(collision.playerId)
         if (!other) continue
-        const dx = collision.normal[0], dy = collision.normal[1], dz = collision.normal[2]
-        const relVx = other.state.velocity[0] - player.state.velocity[0]
-        const relVz = other.state.velocity[2] - player.state.velocity[2]
-        const relDotNorm = relVx * dx + relVz * dz
-        if (relDotNorm >= 0) continue
-        const impulse = (1 + collisionRestitution) * relDotNorm * 0.5
-        player.state.velocity[0] -= impulse * dx * collisionDamping
-        player.state.velocity[2] -= impulse * dz * collisionDamping
-        other.state.velocity[0] += impulse * dx * collisionDamping
-        other.state.velocity[2] += impulse * dz * collisionDamping
+        const nx = collision.normal[0], nz = collision.normal[2]
+        const minDist = physicsIntegration.config.capsuleRadius * 2
+        const overlap = minDist - collision.distance
+        const halfPush = overlap * 0.5
+        const pushVel = Math.min(halfPush / dt, 3.0)
+        player.state.position[0] -= nx * halfPush
+        player.state.position[2] -= nz * halfPush
+        player.state.velocity[0] -= nx * pushVel
+        player.state.velocity[2] -= nz * pushVel
+        other.state.position[0] += nx * halfPush
+        other.state.position[2] += nz * halfPush
+        other.state.velocity[0] += nx * pushVel
+        other.state.velocity[2] += nz * pushVel
+        physicsIntegration.setPlayerPosition(player.id, player.state.position)
+        physicsIntegration.setPlayerPosition(other.id, other.state.position)
       }
     }
+    const t2 = performance.now()
     physics.step(dt)
+    const t3 = performance.now()
     appRuntime.tick(tick, dt)
-    const playerSnap = networkState.getSnapshot()
-    snapshotSeq++
-    if (stageLoader && stageLoader.getActiveStage()) {
-      for (const player of players) {
-        const pos = player.state.position
-        const entitySnap = appRuntime.getSnapshotForPlayer(pos, stageLoader.getActiveStage().spatial.relevanceRadius)
+    const t4 = performance.now()
+    if (players.length > 0) {
+      const playerSnap = networkState.getSnapshot()
+      snapshotSeq++
+      const isKeyframe = snapshotSeq % KEYFRAME_INTERVAL === 0
+      if (stageLoader && stageLoader.getActiveStage()) {
+        for (const player of players) {
+          const pos = player.state.position
+          const entitySnap = appRuntime.getSnapshotForPlayer(pos, stageLoader.getActiveStage().spatial.relevanceRadius)
+          const combined = { tick: playerSnap.tick, timestamp: playerSnap.timestamp, players: playerSnap.players, entities: entitySnap.entities }
+          if (isKeyframe || !playerEntityMaps.has(player.id)) {
+            const encoded = SnapshotEncoder.encode(combined)
+            const { entityMap } = SnapshotEncoder.encodeDelta(combined, new Map())
+            playerEntityMaps.set(player.id, entityMap)
+            connections.send(player.id, MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
+          } else {
+            const prevMap = playerEntityMaps.get(player.id)
+            const { encoded, entityMap } = SnapshotEncoder.encodeDelta(combined, prevMap)
+            playerEntityMaps.set(player.id, entityMap)
+            connections.send(player.id, MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
+          }
+        }
+      } else {
+        const entitySnap = appRuntime.getSnapshot()
         const combined = { tick: playerSnap.tick, timestamp: playerSnap.timestamp, players: playerSnap.players, entities: entitySnap.entities }
-        connections.send(player.id, MSG.SNAPSHOT, { seq: snapshotSeq, ...SnapshotEncoder.encode(combined) })
+        if (isKeyframe || broadcastEntityMap.size === 0) {
+          const encoded = SnapshotEncoder.encode(combined)
+          const { entityMap } = SnapshotEncoder.encodeDelta(combined, new Map())
+          broadcastEntityMap = entityMap
+          connections.broadcast(MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
+        } else {
+          const { encoded, entityMap } = SnapshotEncoder.encodeDelta(combined, broadcastEntityMap)
+          broadcastEntityMap = entityMap
+          connections.broadcast(MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
+        }
       }
-    } else {
-      const entitySnap = appRuntime.getSnapshot()
-      const combined = { tick: playerSnap.tick, timestamp: playerSnap.timestamp, players: playerSnap.players, entities: entitySnap.entities }
-      connections.broadcast(MSG.SNAPSHOT, { seq: snapshotSeq, ...SnapshotEncoder.encode(combined) })
     }
+    for (const id of playerEntityMaps.keys()) {
+      if (!playerManager.getPlayer(id)) playerEntityMaps.delete(id)
+    }
+    const t5 = performance.now()
     try {
       appRuntime._drainReloadQueue()
     } catch (e) {
       console.error('[TickHandler] reload queue error:', e.message)
     }
+    profileLog++
+    if (profileLog % 1280 === 0) {
+      const total = t5 - t0
+      const mem = process.memoryUsage()
+      const heap = (mem.heapUsed / 1048576).toFixed(1)
+      const rss = (mem.rss / 1048576).toFixed(1)
+      const ext = (mem.external / 1048576).toFixed(1)
+      const ab = (mem.arrayBuffers / 1048576).toFixed(1)
+      try { console.log(`[tick-profile] tick:${tick} players:${players.length} total:${total.toFixed(2)}ms | mv:${(t1-t0).toFixed(2)} col:${(t2-t1).toFixed(2)} phys:${(t3-t2).toFixed(2)} app:${(t4-t3).toFixed(2)} snap:${(t5-t4).toFixed(2)} | heap:${heap}MB rss:${rss}MB ext:${ext}MB ab:${ab}MB`) } catch (_) {}
+    }
   }
 }

package/src/sdk/scaffold.js

@@ -0,0 +1,28 @@
+import { join, dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { existsSync, mkdirSync, readdirSync, copyFileSync, statSync } from 'node:fs'
+
+const SDK_ROOT = join(dirname(fileURLToPath(import.meta.url)), '../..')
+
+function copyDir(src, dest) {
+  mkdirSync(dest, { recursive: true })
+  for (const entry of readdirSync(src, { withFileTypes: true })) {
+    const s = join(src, entry.name)
+    const d = join(dest, entry.name)
+    if (entry.isDirectory()) copyDir(s, d)
+    else copyFileSync(s, d)
+  }
+}
+
+export async function scaffold() {
+  const cwd = process.cwd()
+  const localApps = resolve(cwd, 'apps')
+  if (existsSync(localApps)) {
+    console.log(`[scaffold] apps/ already exists at ${localApps}, skipping`)
+    return
+  }
+  const sdkApps = join(SDK_ROOT, 'apps')
+  copyDir(sdkApps, localApps)
+  console.log(`[scaffold] created apps/ at ${localApps}`)
+  console.log(`[scaffold] run 'spoint' to start the server`)
+}