spoint 0.1.79 → 0.1.81

package/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: spoint
-description: "Build multiplayer physics games with the Spawnpoint engine. Use when asked to: create a game, add physics objects, spawn entities, build an arena, handle player interaction, add weapons, respawn, scoring, create moving platforms, manage world config, load 3D models, add HUD/UI, work with the EventBus, or develop any app inside an apps/ directory."
+description: "Build multiplayer physics games with the Spawnpoint engine. Use when asked to: create a game, add physics objects, spawn entities, build a map/level, handle player interaction, add weapons, respawn, scoring, create moving platforms, manage world config, load 3D models, add HUD/UI, work with the EventBus, or develop any app inside an apps/ directory."
 ---
 
 # Spawnpoint App Development Reference
@@ -26,36 +26,30 @@ export default {
   movement: { maxSpeed: 4.0, groundAccel: 10.0, airAccel: 1.0, friction: 6.0, stopSpeed: 2.0, jumpImpulse: 4.0 },
   player: { health: 100, capsuleRadius: 0.4, capsuleHalfHeight: 0.9, modelScale: 1.323, feetOffset: 0.212 },
   scene: { skyColor: 0x87ceeb, fogColor: 0x87ceeb, fogNear: 80, fogFar: 200, sunIntensity: 1.5, sunPosition: [20, 40, 20] },
-  entities: [{ id: 'arena', position: [0,0,0], app: 'arena' }],
+  entities: [{ id: 'environment', model: './apps/game/map.glb', position: [0,0,0], app: 'environment' }],
   spawnPoint: [0, 2, 0]
 }
 ```
 
-### `apps/arena/index.js`
+### `apps/environment/index.js` — static environment with trimesh physics
 ```js
-const HALF = 12, WH = 3, WT = 0.5
-const WALLS = [
-  { id:'wn', x:0,     y:WH/2, z:-HALF, hx:HALF,  hy:WH/2, hz:WT/2 },
-  { id:'ws', x:0,     y:WH/2, z: HALF, hx:HALF,  hy:WH/2, hz:WT/2 },
-  { id:'we', x: HALF, y:WH/2, z:0,     hx:WT/2,  hy:WH/2, hz:HALF },
-  { id:'ww', x:-HALF, y:WH/2, z:0,     hx:WT/2,  hy:WH/2, hz:HALF },
-]
 export default {
   server: {
-    setup(ctx) {
-      ctx.state.ids = ctx.state.ids || []
-      if (ctx.state.ids.length > 0) return  // hot-reload guard
-      ctx.entity.custom = { mesh:'box', color:0x5a7a4a, sx:HALF*2, sy:0.5, sz:HALF*2 }
+    async setup(ctx) {
       ctx.physics.setStatic(true)
-      ctx.physics.addBoxCollider([HALF, 0.25, HALF])
-      for (const w of WALLS) {
-        const e = ctx.world.spawn(w.id, { position:[w.x,w.y,w.z], app:'box-static', config:{ hx:w.hx, hy:w.hy, hz:w.hz, color:0x7a6a5a } })
-        if (e) ctx.state.ids.push(w.id)
+      try {
+        await ctx.physics.addTrimeshCollider()
+      } catch (e) {
+        console.log(\`Trimesh failed: \${e.message}, using box fallback\`)
+        ctx.physics.addBoxCollider([100, 25, 100])
       }
-    },
-    teardown(ctx) { for (const id of ctx.state.ids||[]) ctx.world.destroy(id); ctx.state.ids = [] }
+    }
   },
-  client: { render(ctx) { return { position:ctx.entity.position, rotation:ctx.entity.rotation, custom:ctx.entity.custom } } }
+  client: {
+    render(ctx) {
+      return { model: ctx.entity.model, position: ctx.entity.position, rotation: ctx.entity.rotation }
+    }
+  }
 }
 ```
 

package/apps/environment/index.js

@@ -23,11 +23,16 @@ function discoverModels() {
 
 export default {
   server: {
-    setup(ctx) {
+    async setup(ctx) {
       ctx.physics.setStatic(true)
-      // Use simple box collider for environment - trimesh creation is too slow for large meshes
-      // The environment is primarily visual; players collide with box bounds instead
-      ctx.physics.addBoxCollider([50, 15, 50])
+      // Use trimesh collider for accurate environment collision
+      // Deferred to background so server startup isn't blocked
+      try {
+        await ctx.physics.addTrimeshCollider()
+      } catch (e) {
+        console.log(`[Environment] Trimesh collider failed: ${e.message}, using box collider`)
+        ctx.physics.addBoxCollider([100, 25, 100])
+      }
 
       ctx.state.smartObjects = new Map()
       ctx.state.editorMode = false

package/apps/world/index.js

@@ -1,70 +1,65 @@
-export default {
-  port: 3001,
-  tickRate: 128,
-  gravity: [0, -9.81, 0],
-  movement: {
-    maxSpeed: 4.0,
-    groundAccel: 10.0,
-    airAccel: 1.0,
-    friction: 6.0,
-    stopSpeed: 2.0,
-    jumpImpulse: 4.0,
-    collisionRestitution: 0.2,
-    collisionDamping: 0.25
-  },
-  player: {
-    health: 100,
-    capsuleRadius: 0.4,
-    capsuleHalfHeight: 0.9,
-    crouchHalfHeight: 0.45,
-    mass: 120,
-    modelScale: 1.323,
-    feetOffset: 0.212
-  },
-  scene: {
-    skyColor: 0x87ceeb,
-    fogColor: 0x87ceeb,
-    fogNear: 80,
-    fogFar: 200,
-    ambientColor: 0xfff4d6,
-    ambientIntensity: 0.3,
-    sunColor: 0xffffff,
-    sunIntensity: 1.5,
-    sunPosition: [21, 50, 20],
-    fillColor: 0x4488ff,
-    fillIntensity: 0.4,
-    fillPosition: [-20, 30, -10],
-    shadowMapSize: 1024,
-    shadowBias: 0.0038,
-    shadowNormalBias: 0.6,
-    shadowRadius: 12,
-    shadowBlurSamples: 8
-  },
-  camera: {
-    fov: 70,
-    shoulderOffset: 0.35,
-    headHeight: 0.4,
-    zoomStages: [0, 1.5, 3, 5, 8],
-    defaultZoomIndex: 2,
-    followSpeed: 12.0,
-    snapSpeed: 30.0,
-    mouseSensitivity: 0.002,
-    pitchRange: [-1.4, 1.4]
-  },
-  animation: {
-    mixerTimeScale: 1.3,
-    walkTimeScale: 2.0,
-    sprintTimeScale: 0.56,
-    fadeTime: 0.15
-  },
-  entities: [
-    { id: 'environment', model: './apps/tps-game/schwust.glb', position: [0, -10, 0], app: 'environment' },
-    { id: 'game', position: [0, 0, 0], app: 'tps-game' },
-    { id: 'power-crates', position: [0, 0, 0], app: 'power-crate' },
-    { id: 'interact-box', position: [-100, 3, -100], app: 'interactable' }
-    // To use the primitive arena instead of schwust.glb, replace above with:
-    // { id: 'arena', position: [0, 0, 0], app: 'arena' }
-  ],
-  playerModel: './apps/tps-game/cleetus.vrm',
-  spawnPoint: [-35, 3, -65]
-}
+export default {
+  port: 3001,
+  tickRate: 128,
+  gravity: [0, -9.81, 0],
+  movement: {
+    maxSpeed: 4.0,
+    groundAccel: 10.0,
+    airAccel: 1.0,
+    friction: 6.0,
+    stopSpeed: 2.0,
+    jumpImpulse: 4.0,
+    collisionRestitution: 0.2,
+    collisionDamping: 0.25
+  },
+  player: {
+    health: 100,
+    capsuleRadius: 0.4,
+    capsuleHalfHeight: 0.9,
+    crouchHalfHeight: 0.45,
+    mass: 120,
+    modelScale: 1.323,
+    feetOffset: 0.212
+  },
+  scene: {
+    skyColor: 0x87ceeb,
+    fogColor: 0x87ceeb,
+    fogNear: 80,
+    fogFar: 200,
+    ambientColor: 0xfff4d6,
+    ambientIntensity: 0.3,
+    sunColor: 0xffffff,
+    sunIntensity: 1.5,
+    sunPosition: [21, 50, 20],
+    fillColor: 0x4488ff,
+    fillIntensity: 0.4,
+    fillPosition: [-20, 30, -10],
+    shadowMapSize: 1024,
+    shadowBias: 0.0038,
+    shadowNormalBias: 0.6,
+    shadowRadius: 12,
+    shadowBlurSamples: 8
+  },
+  camera: {
+    fov: 70,
+    shoulderOffset: 0.35,
+    headHeight: 0.4,
+    zoomStages: [0, 1.5, 3, 5, 8],
+    defaultZoomIndex: 2,
+    followSpeed: 12.0,
+    snapSpeed: 30.0,
+    mouseSensitivity: 0.002,
+    pitchRange: [-1.4, 1.4]
+  },
+  animation: {
+    mixerTimeScale: 1.3,
+    walkTimeScale: 2.0,
+    sprintTimeScale: 0.56,
+    fadeTime: 0.15
+  },
+  entities: [
+    { id: 'environment', model: './apps/tps-game/schwust.glb', position: [0, 0, 0], app: 'environment' }
+  ],
+  playerModel: './apps/tps-game/cleetus.vrm',
+  spawnPoint: [-30, 7.6, -30]
+}

package/client/app.js

@@ -5,6 +5,7 @@ THREE.BufferGeometry.prototype.disposeBoundsTree = disposeBoundsTree
 THREE.Mesh.prototype.raycast = acceleratedRaycast
 import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'
 import { DRACOLoader } from 'three/addons/loaders/DRACOLoader.js'
+import { MeshoptDecoder } from 'three/addons/libs/meshopt_decoder.module.js'
 import { VRMLoaderPlugin, VRMUtils } from '@pixiv/three-vrm'
 import { PhysicsNetworkClient, InputHandler, MSG } from '/src/index.client.js'
 import { createElement, applyDiff } from 'webjsx'
@@ -675,6 +676,7 @@ const dracoLoader = new DRACOLoader(loadingManager)
 dracoLoader.setDecoderPath('/draco/')
 dracoLoader.setWorkerLimit(1)
 gltfLoader.setDRACOLoader(dracoLoader)
+gltfLoader.setMeshoptDecoder(MeshoptDecoder)
 gltfLoader.register((parser) => new VRMLoaderPlugin(parser))
 const playerMeshes = new Map()
 const playerAnimators = new Map()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spoint",
-  "version": "0.1.79",
+  "version": "0.1.81",
   "description": "Physics and netcode SDK for multiplayer game servers",
   "type": "module",
   "main": "src/index.js",

package/src/apps/AppContext.js

@@ -69,10 +69,10 @@ export class AppContext {
         }
       },
       addMeshCollider: (m) => { ent.collider = { type: 'mesh', mesh: m } },
-      addTrimeshCollider: () => {
+      addTrimeshCollider: async () => {
         ent.collider = { type: 'trimesh', model: ent.model }
         if (runtime._physics && ent.model) {
-          const bodyId = runtime._physics.addStaticTrimesh(runtime.resolveAssetPath(ent.model), 0)
+          const bodyId = await runtime._physics.addStaticTrimeshAsync(runtime.resolveAssetPath(ent.model), 0, ent.position)
           ent._physicsBodyId = bodyId
         }
       },

package/src/apps/AppRuntime.js

@@ -64,25 +64,27 @@ export class AppRuntime {
     }
     if (config.autoTrimesh && entity.model && this._physics) {
       entity.collider = { type: 'trimesh', model: entity.model }
-      entity._physicsBodyId = this._physics.addStaticTrimesh(this.resolveAssetPath(entity.model), 0)
+      this._physics.addStaticTrimeshAsync(this.resolveAssetPath(entity.model), 0, entity.position || [0,0,0])
+        .then(id => { entity._physicsBodyId = id })
+        .catch(e => console.error(`[AppRuntime] Failed to create trimesh for ${entity.model}:`, e.message))
     }
-    if (config.app) this._attachApp(entityId, config.app)
+    if (config.app) this._attachApp(entityId, config.app).catch(e => console.error(`[AppRuntime] Failed to attach app ${config.app}:`, e.message))
     this._spatialInsert(entity)
     return entity
   }
 
-  _attachApp(entityId, appName) {
+  async _attachApp(entityId, appName) {
     const entity = this.entities.get(entityId), appDef = this._appDefs.get(appName)
     if (!entity || !appDef) return
     const ctx = new AppContext(entity, this)
     this.contexts.set(entityId, ctx); this.apps.set(entityId, appDef)
-    this._safeCall(appDef.server || appDef, 'setup', [ctx], `setup(${appName})`)
+    await this._safeCall(appDef.server || appDef, 'setup', [ctx], `setup(${appName})`)
   }
 
-  attachApp(entityId, appName) { this._attachApp(entityId, appName) }
-  spawnWithApp(id, cfg = {}, app) { return this.spawnEntity(id, { ...cfg, app }) }
-  attachAppToEntity(eid, app, cfg = {}) { const e = this.getEntity(eid); if (!e) return false; e._config = cfg; this._attachApp(eid, app); return true }
-  reattachAppToEntity(eid, app) { this.detachApp(eid); this._attachApp(eid, app) }
+  async attachApp(entityId, appName) { await this._attachApp(entityId, appName) }
+  async spawnWithApp(id, cfg = {}, app) { return await this.spawnEntity(id, { ...cfg, app }) }
+  async attachAppToEntity(eid, app, cfg = {}) { const e = this.getEntity(eid); if (!e) return false; e._config = cfg; await this._attachApp(eid, app); return true }
+  async reattachAppToEntity(eid, app) { this.detachApp(eid); await this._attachApp(eid, app) }
   getEntityWithApp(eid) { const e = this.entities.get(eid); return { entity: e, appName: e?._appName, hasApp: !!e?._appName } }
 
   detachApp(entityId) {
@@ -234,5 +236,17 @@ export class AppRuntime {
   relevantEntities(position, radius) { if (!this._stageLoader) return Array.from(this.entities.keys()); return this._stageLoader.getRelevantEntities(position, radius) }
 
   _log(type, data, meta = {}) { if (this._eventLog) this._eventLog.record(type, data, { ...meta, tick: this.currentTick }) }
-  _safeCall(o, m, a, l) { if (!o?.[m]) return; try { o[m](...a) } catch (e) { console.error(`[AppRuntime] ${l}: ${e.message}\n  ${e.stack?.split('\n').slice(1, 3).join('\n  ') || ''}`) } }
+  _safeCall(o, m, a, l) {
+    if (!o?.[m]) return Promise.resolve()
+    try {
+      const result = o[m](...a)
+      if (result && typeof result.catch === 'function') {
+        return result.catch(e => console.error(`[AppRuntime] ${l}: ${e.message}\n  ${e.stack?.split('\n').slice(1, 3).join('\n  ') || ''}`))
+      }
+      return Promise.resolve()
+    } catch (e) {
+      console.error(`[AppRuntime] ${l}: ${e.message}\n  ${e.stack?.split('\n').slice(1, 3).join('\n  ') || ''}`)
+      return Promise.reject(e)
+    }
+  }
 }

package/src/physics/GLBLoader.js

@@ -1,6 +1,7 @@
 import { readFileSync } from 'node:fs'
 
 let _dracoDecoderPromise = null
+let _meshoptDecoderPromise = null
 
 async function getDracoDecoder() {
   if (!_dracoDecoderPromise) {
@@ -14,6 +15,19 @@ async function getDracoDecoder() {
   return _dracoDecoderPromise
 }
 
+async function getMeshoptDecoder() {
+  if (!_meshoptDecoderPromise) {
+    try {
+      const meshopt = await import('meshoptimizer')
+      _meshoptDecoderPromise = meshopt.MeshoptDecoder
+      await _meshoptDecoderPromise.ready
+    } catch(e) {
+      throw new Error(`Failed to load Meshopt decoder: ${e.message}`)
+    }
+  }
+  return _meshoptDecoderPromise
+}
+
 /**
  * Extract mesh from GLB file for physics collider creation.
  * Supports both standard and Draco-compressed meshes.
@@ -42,6 +56,13 @@ export function extractMeshFromGLB(filepath, meshIndex = 0) {
     throw new Error('Draco-compressed mesh detected. Use extractMeshFromGLBAsync() instead.')
   }
 
+  // Check for meshopt compression (not supported)
+  const hasMeshopt = json.bufferViews?.some(bv => bv.extensions?.EXT_meshopt_compression) ||
+    json.meshes.some(m => m.primitives.some(p => p.extensions?.EXT_meshopt_compression))
+  if (hasMeshopt) {
+    throw new Error('Meshopt-compressed mesh detected. Decompress with gltfpack first: gltfpack -i input.glb -o output.glb -noq')
+  }
+
   // Standard uncompressed GLB mesh extraction
   const posAcc = json.accessors[prim.attributes.POSITION]
   const posView = json.bufferViews[posAcc.bufferView]
@@ -61,13 +82,24 @@ export function extractMeshFromGLB(filepath, meshIndex = 0) {
     }
   }
 
-  return {
+  const result = {
     vertices,
     indices,
     vertexCount: posAcc.count,
     triangleCount: indices ? indices.length / 3 : 0,
     name: mesh.name
   }
+  
+  const node = json.nodes?.find(n => n.mesh === meshIndex)
+  if (node) {
+    result.nodeTransform = {
+      scale: node.scale ? [...node.scale] : null,
+      rotation: node.rotation ? [...node.rotation] : null,
+      translation: node.translation ? [...node.translation] : null
+    }
+  }
+
+  return result
 }
 
 /**
@@ -92,12 +124,29 @@ export async function extractMeshFromGLBAsync(filepath, meshIndex = 0) {
 
   const prim = mesh.primitives[0]
 
-  // Handle Draco-compressed mesh
+  let result
+  
   if (prim.extensions?.KHR_draco_mesh_compression) {
-    return decompressDracoMesh(buf, json, prim, binOffset, mesh.name)
+    result = await decompressDracoMesh(buf, json, prim, binOffset, mesh.name)
+  } else if (json.bufferViews?.some(bv => bv.extensions?.EXT_meshopt_compression)) {
+    result = await extractMeshWithMeshopt(buf, json, prim, binOffset, mesh.name)
+  } else {
+    result = extractStandardMesh(buf, json, prim, binOffset, mesh.name)
   }
 
-  // Standard uncompressed extraction
+  const node = json.nodes?.find(n => n.mesh === meshIndex)
+  if (node) {
+    result.nodeTransform = {
+      scale: node.scale ? [...node.scale] : null,
+      rotation: node.rotation ? [...node.rotation] : null,
+      translation: node.translation ? [...node.translation] : null
+    }
+  }
+
+  return result
+}
+
+function extractStandardMesh(buf, json, prim, binOffset, meshName) {
   const posAcc = json.accessors[prim.attributes.POSITION]
   const posView = json.bufferViews[posAcc.bufferView]
   const posOff = binOffset + (posView.byteOffset || 0) + (posAcc.byteOffset || 0)
@@ -121,7 +170,40 @@ export async function extractMeshFromGLBAsync(filepath, meshIndex = 0) {
     indices,
     vertexCount: posAcc.count,
     triangleCount: indices ? indices.length / 3 : 0,
-    name: mesh.name
+    name: meshName
+  }
+}
+
+function applyNodeTransform(vertices, node) {
+  const scale = node.scale ? [node.scale[0], node.scale[1], node.scale[2]] : [1, 1, 1]
+  const translation = node.translation ? [node.translation[0], node.translation[1], node.translation[2]] : [0, 0, 0]
+  
+  if (node.rotation) {
+    const [qx, qy, qz, qw] = node.rotation
+    for (let i = 0; i < vertices.length / 3; i++) {
+      let x = vertices[i * 3] * scale[0]
+      let y = vertices[i * 3 + 1] * scale[1]
+      let z = vertices[i * 3 + 2] * scale[2]
+      
+      const ix = qw * x + qy * z - qz * y
+      const iy = qw * y + qz * x - qx * z
+      const iz = qw * z + qx * y - qy * x
+      const iw = -qx * x - qy * y - qz * z
+      
+      x = ix * qw - iw * qx - iy * qz + iz * qy
+      y = iy * qw - iw * qy - iz * qx + ix * qz
+      z = iz * qw - iw * qz - ix * qy + iy * qx
+      
+      vertices[i * 3] = x + translation[0]
+      vertices[i * 3 + 1] = y + translation[1]
+      vertices[i * 3 + 2] = z + translation[2]
+    }
+  } else {
+    for (let i = 0; i < vertices.length / 3; i++) {
+      vertices[i * 3] = vertices[i * 3] * scale[0] + translation[0]
+      vertices[i * 3 + 1] = vertices[i * 3 + 1] * scale[1] + translation[1]
+      vertices[i * 3 + 2] = vertices[i * 3 + 2] * scale[2] + translation[2]
+    }
   }
 }
 
@@ -135,76 +217,341 @@ async function decompressDracoMesh(buf, json, prim, binOffset, meshName) {
   const length = bufView.byteLength
   const dracoData = buf.slice(offset, offset + length)
 
-  // Create decoder and buffer
   const d = new decoder.Decoder()
   const db = new decoder.DecoderBuffer()
+  const decodedGeom = new decoder.Mesh()
 
   try {
-    // Initialize buffer
     const dracoArray = new Uint8Array(dracoData)
     db.Init(dracoArray, dracoArray.length)
 
-    // Decode mesh
-    const decodedGeom = d.DecodeBufferToMesh(db)
-    if (!decodedGeom) {
-      throw new Error('Draco decompression failed: empty result')
+    const status = d.DecodeBufferToMesh(db, decodedGeom)
+    if (!status.ok()) {
+      throw new Error(`Draco decompression failed: ${status.error_msg()}`)
     }
 
-    // Get position attribute
-    const posAttrId = d.GetAttributeIdByName(decodedGeom, 'POSITION')
+    const posAttrId = d.GetAttributeId(decodedGeom, decoder.POSITION)
     if (posAttrId < 0) {
       throw new Error('No POSITION attribute in decompressed mesh')
     }
 
     const posAttr = d.GetAttribute(decodedGeom, posAttrId)
-    const posData = d.GetAttributeFloatForAllPoints(decodedGeom, posAttr)
-    const vertices = new Float32Array(posData)
+    const numPoints = decodedGeom.num_points()
+    const posData = new decoder.DracoFloat32Array()
+    d.GetAttributeFloatForAllPoints(decodedGeom, posAttr, posData)
+    
+    const vertices = new Float32Array(numPoints * 3)
+    for (let i = 0; i < numPoints * 3; i++) {
+      vertices[i] = posData.GetValue(i)
+    }
 
-    // Get indices if available
     let indices = null
-    if (decodedGeom.num_faces() > 0) {
-      const indicesData = d.GetTrianglesUInt32Array(decodedGeom, decodedGeom.num_faces())
-      indices = new Uint32Array(indicesData)
+    const numFaces = decodedGeom.num_faces()
+    if (numFaces > 0) {
+      indices = new Uint32Array(numFaces * 3)
+      const faceIndices = new decoder.DracoUInt32Array()
+      for (let i = 0; i < numFaces; i++) {
+        d.GetFaceFromMesh(decodedGeom, i, faceIndices)
+        indices[i * 3] = faceIndices.GetValue(0)
+        indices[i * 3 + 1] = faceIndices.GetValue(1)
+        indices[i * 3 + 2] = faceIndices.GetValue(2)
+      }
+      decoder.destroy(faceIndices)
     }
 
-    decoder.destroy(decodedGeom)
+    decoder.destroy(posData)
+    decoder.destroy(status)
 
     return {
       vertices,
       indices,
-      vertexCount: decodedGeom.num_points(),
-      triangleCount: decodedGeom.num_faces(),
+      vertexCount: numPoints,
+      triangleCount: numFaces,
       name: meshName
     }
   } finally {
+    decoder.destroy(decodedGeom)
     decoder.destroy(d)
     decoder.destroy(db)
   }
 }
 
+async function extractMeshWithMeshopt(buf, json, prim, binOffset, meshName) {
+  const decoder = await getMeshoptDecoder()
+  
+  const posAcc = json.accessors[prim.attributes.POSITION]
+  const posView = json.bufferViews[posAcc.bufferView]
+  const posExt = posView.extensions?.EXT_meshopt_compression
+  
+  if (!posExt) {
+    throw new Error('Position buffer view has no EXT_meshopt_compression extension')
+  }
+  
+  const posSrcOff = binOffset + (posExt.byteOffset || 0)
+  const posSrcLen = posExt.byteLength
+  const posSrc = new Uint8Array(buf.buffer.slice(posSrcOff, posSrcOff + posSrcLen))
+  
+  const numVertices = posExt.count
+  const stride = posExt.byteStride || 12
+  const posDst = new Uint8Array(numVertices * stride)
+  
+  const mode = posExt.mode || 'ATTRIBUTES'
+  const filter = posExt.filter || 'NONE'
+  decoder.decodeGltfBuffer(posDst, numVertices, stride, posSrc, mode, filter)
+  
+  const vertices = new Float32Array(numVertices * 3)
+  
+  // Handle normalized INT16 positions (common in meshopt-compressed models)
+  // Normalized INT16: float = raw / 32767.0
+  if (stride === 8 && posAcc.normalized && posAcc.componentType === 5122) {
+    const raw = new Int16Array(posDst.buffer)
+    for (let i = 0; i < numVertices; i++) {
+      vertices[i * 3] = raw[i * 4] / 32767.0
+      vertices[i * 3 + 1] = raw[i * 4 + 1] / 32767.0
+      vertices[i * 3 + 2] = raw[i * 4 + 2] / 32767.0
+    }
+  } else if (stride === 12) {
+    vertices.set(new Float32Array(posDst.buffer))
+  } else {
+    const floats = new Float32Array(posDst.buffer)
+    for (let i = 0; i < numVertices; i++) {
+      vertices[i * 3] = floats[i * (stride / 4)]
+      vertices[i * 3 + 1] = floats[i * (stride / 4) + 1]
+      vertices[i * 3 + 2] = floats[i * (stride / 4) + 2]
+    }
+  }
+  
+  let indices = null
+  if (prim.indices !== undefined) {
+    const idxAcc = json.accessors[prim.indices]
+    const idxView = json.bufferViews[idxAcc.bufferView]
+    const idxExt = idxView.extensions?.EXT_meshopt_compression
+    
+    if (idxExt) {
+      const idxSrcOff = binOffset + (idxExt.byteOffset || 0)
+      const idxSrcLen = idxExt.byteLength
+      const idxSrc = new Uint8Array(buf.buffer.slice(idxSrcOff, idxSrcOff + idxSrcLen))
+      
+      const idxStride = idxExt.byteStride || 2
+      const numIndices = idxExt.count
+      const idxDst = new Uint8Array(numIndices * idxStride)
+      
+      const idxMode = idxExt.mode || 'TRIANGLES'
+      const idxFilter = idxExt.filter || 'NONE'
+      decoder.decodeGltfBuffer(idxDst, numIndices, idxStride, idxSrc, idxMode, idxFilter)
+      
+      if (idxAcc.componentType === 5123) {
+        indices = new Uint32Array(new Uint16Array(idxDst.buffer))
+      } else {
+        indices = new Uint32Array(idxDst.buffer)
+      }
+    } else {
+      const idxOff = binOffset + (idxView.byteOffset || 0) + (idxAcc.byteOffset || 0)
+      if (idxAcc.componentType === 5123) {
+        indices = new Uint32Array(new Uint16Array(buf.buffer.slice(idxOff, idxOff + idxAcc.count * 2)))
+      } else {
+        indices = new Uint32Array(buf.buffer.slice(idxOff, idxOff + idxAcc.count * 4))
+      }
+    }
+  }
+  
+  return {
+    vertices,
+    indices,
+    vertexCount: numVertices,
+    triangleCount: indices ? indices.length / 3 : 0,
+    name: meshName
+  }
+}
+
+/**
+ * Extract ALL meshes and ALL primitives from a GLB file and combine them into
+ * a single flat vertex/index buffer suitable for a trimesh collider.
+ * Handles Draco-compressed primitives. Used for map collision where the GLB
+ * may have dozens of meshes each with many primitives.
+ *
+ * @param {string} filepath - Path to GLB file
+ * @returns {Promise<Object>} {vertices: Float32Array, indices: Uint32Array, vertexCount, triangleCount}
+ */
+export async function extractAllMeshesFromGLBAsync(filepath) {
+  console.log(`[GLBLoader] Extracting ALL meshes from: ${filepath}`)
+  const buf = readFileSync(filepath)
+  if (buf.toString('ascii', 0, 4) !== 'glTF') throw new Error('Not a GLB file')
+
+  const jsonLen = buf.readUInt32LE(12)
+  const json = JSON.parse(buf.toString('utf-8', 20, 20 + jsonLen))
+  const binOffset = 20 + jsonLen + 8
+
+  const allVertices = []
+  const allIndices = []
+  let vertexOffset = 0
+  let totalTriangles = 0
+
+  // Build a node->transform map for node hierarchy
+  const nodeTransforms = buildNodeTransforms(json)
+
+  for (let meshIdx = 0; meshIdx < (json.meshes || []).length; meshIdx++) {
+    const mesh = json.meshes[meshIdx]
+    // Find node referencing this mesh to get its world transform
+    const nodeIdx = (json.nodes || []).findIndex(n => n.mesh === meshIdx)
+    const worldTransform = nodeIdx >= 0 ? nodeTransforms[nodeIdx] : null
+
+    for (let primIdx = 0; primIdx < mesh.primitives.length; primIdx++) {
+      const prim = mesh.primitives[primIdx]
+      let result
+      try {
+        if (prim.extensions?.KHR_draco_mesh_compression) {
+          result = await decompressDracoMesh(buf, json, prim, binOffset, mesh.name)
+        } else {
+          result = extractStandardMesh(buf, json, prim, binOffset, mesh.name)
+        }
+      } catch (e) {
+        console.warn(`[GLBLoader] Skipping mesh[${meshIdx}] prim[${primIdx}]: ${e.message}`)
+        continue
+      }
+
+      if (!result.indices || result.triangleCount === 0) continue
+
+      // Apply world transform to vertices if present
+      let verts = result.vertices
+      if (worldTransform) {
+        verts = applyTransformMatrix(result.vertices, worldTransform)
+      }
+
+      allVertices.push(verts)
+      // Remap indices by current vertex offset
+      const remapped = new Uint32Array(result.indices.length)
+      for (let i = 0; i < result.indices.length; i++) {
+        remapped[i] = result.indices[i] + vertexOffset
+      }
+      allIndices.push(remapped)
+      vertexOffset += result.vertexCount
+      totalTriangles += result.triangleCount
+    }
+  }
+
+  if (allVertices.length === 0) throw new Error('No valid mesh primitives found in GLB')
+
+  // Concatenate all vertex and index arrays
+  const totalVerts = vertexOffset
+  const combinedVertices = new Float32Array(totalVerts * 3)
+  let vOff = 0
+  for (const v of allVertices) { combinedVertices.set(v, vOff); vOff += v.length }
+
+  const combinedIndices = new Uint32Array(totalTriangles * 3)
+  let iOff = 0
+  for (const idx of allIndices) { combinedIndices.set(idx, iOff); iOff += idx.length }
+
+  console.log(`[GLBLoader] Combined: ${totalVerts} vertices, ${totalTriangles} triangles from ${allIndices.length} primitives`)
+  return { vertices: combinedVertices, indices: combinedIndices, vertexCount: totalVerts, triangleCount: totalTriangles }
+}
+
+/**
+ * Build world-space 4x4 transform matrices for every node in the scene graph.
+ * Returns an array indexed by node index.
+ */
+function buildNodeTransforms(json) {
+  const nodes = json.nodes || []
+  const matrices = new Array(nodes.length).fill(null)
+
+  function getMatrix(nodeIdx) {
+    if (matrices[nodeIdx] !== null) return matrices[nodeIdx]
+    const node = nodes[nodeIdx]
+    let local = mat4Identity()
+    if (node.matrix) {
+      local = node.matrix.slice()
+    } else {
+      const t = node.translation || [0, 0, 0]
+      const r = node.rotation || [0, 0, 0, 1]
+      const s = node.scale || [1, 1, 1]
+      local = mat4TRS(t, r, s)
+    }
+    // Find parent
+    const parentIdx = nodes.findIndex((n, i) => i !== nodeIdx && (n.children || []).includes(nodeIdx))
+    if (parentIdx >= 0) {
+      local = mat4Mul(getMatrix(parentIdx), local)
+    }
+    matrices[nodeIdx] = local
+    return local
+  }
+
+  for (let i = 0; i < nodes.length; i++) getMatrix(i)
+  return matrices
+}
+
+function mat4Identity() {
+  return [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]
+}
+
+function mat4TRS(t, r, s) {
+  const [qx, qy, qz, qw] = r
+  const [sx, sy, sz] = s
+  const x2=qx+qx, y2=qy+qy, z2=qz+qz
+  const xx=qx*x2, xy=qx*y2, xz=qx*z2
+  const yy=qy*y2, yz=qy*z2, zz=qz*z2
+  const wx=qw*x2, wy=qw*y2, wz=qw*z2
+  return [
+    (1-(yy+zz))*sx, (xy+wz)*sx,    (xz-wy)*sx,    0,
+    (xy-wz)*sy,     (1-(xx+zz))*sy,(yz+wx)*sy,    0,
+    (xz+wy)*sz,     (yz-wx)*sz,    (1-(xx+yy))*sz,0,
+    t[0], t[1], t[2], 1
+  ]
+}
+
+function mat4Mul(a, b) {
+  const out = new Array(16)
+  for (let row = 0; row < 4; row++) {
+    for (let col = 0; col < 4; col++) {
+      let sum = 0
+      for (let k = 0; k < 4; k++) sum += a[row + k*4] * b[k + col*4]
+      out[row + col*4] = sum
+    }
+  }
+  return out
+}
+
+function applyTransformMatrix(vertices, m) {
+  const count = vertices.length / 3
+  const out = new Float32Array(vertices.length)
+  for (let i = 0; i < count; i++) {
+    const x = vertices[i*3], y = vertices[i*3+1], z = vertices[i*3+2]
+    out[i*3]   = m[0]*x + m[4]*y + m[8]*z  + m[12]
+    out[i*3+1] = m[1]*x + m[5]*y + m[9]*z  + m[13]
+    out[i*3+2] = m[2]*x + m[6]*y + m[10]*z + m[14]
+  }
+  return out
+}
+
 /**
  * Check if a GLB file has Draco-compressed meshes without attempting extraction.
  * Useful for validation and error reporting.
  * 
  * @param {string} filepath - Path to GLB file
- * @returns {Object} {hasDraco: boolean, meshes: Array<{name, hasDraco}>}
+ * @returns {Object} {hasDraco: boolean, hasMeshopt: boolean, meshes: Array<{name, hasDraco, hasMeshopt}>}
  */
 export function detectDracoInGLB(filepath) {
   try {
     const buf = readFileSync(filepath)
-    if (buf.toString('ascii', 0, 4) !== 'glTF') return { hasDraco: false, meshes: [] }
+    if (buf.toString('ascii', 0, 4) !== 'glTF') return { hasDraco: false, hasMeshopt: false, meshes: [] }
     
     const jsonLen = buf.readUInt32LE(12)
     const json = JSON.parse(buf.toString('utf-8', 20, 20 + jsonLen))
     
-    const meshes = (json.meshes || []).map(mesh => ({
-      name: mesh.name || 'unnamed',
-      hasDraco: mesh.primitives?.some(p => p.extensions?.KHR_draco_mesh_compression) || false
-    }))
+    const bufferViewHasMeshopt = (bv) => bv.extensions?.EXT_meshopt_compression
+    const hasMeshoptGlobally = (json.bufferViews || []).some(bufferViewHasMeshopt)
     
-    const hasDraco = meshes.some(m => m.hasDraco)
-    return { hasDraco, meshes }
+    const meshes = (json.meshes || []).map(mesh => {
+      const hasDraco = mesh.primitives?.some(p => p.extensions?.KHR_draco_mesh_compression) || false
+      const hasMeshopt = hasMeshoptGlobally || mesh.primitives?.some(p => p.extensions?.EXT_meshopt_compression) || false
+      return { name: mesh.name || 'unnamed', hasDraco, hasMeshopt }
+    })
+    
+    return {
+      hasDraco: meshes.some(m => m.hasDraco),
+      hasMeshopt: meshes.some(m => m.hasMeshopt),
+      meshes
+    }
   } catch (e) {
-    return { hasDraco: false, meshes: [], error: e.message }
+    return { hasDraco: false, hasMeshopt: false, meshes: [], error: e.message }
   }
 }

package/src/physics/World.js

@@ -1,5 +1,5 @@
 import initJolt from 'jolt-physics/wasm-compat'
-import { extractMeshFromGLB } from './GLBLoader.js'
+import { extractMeshFromGLB, extractMeshFromGLBAsync, extractAllMeshesFromGLBAsync } from './GLBLoader.js'
 const LAYER_STATIC = 0, LAYER_DYNAMIC = 1, NUM_LAYERS = 2
 let joltInstance = null
 async function getJolt() { if (!joltInstance) joltInstance = await initJolt(); return joltInstance }
@@ -74,17 +74,89 @@ export class PhysicsWorld {
   addStaticTrimesh(glbPath, meshIndex = 0) {
     const J = this.Jolt
     const mesh = extractMeshFromGLB(glbPath, meshIndex)
+    
+    // Apply node transform if present (scale, rotation, translation)
+    let vertices = mesh.vertices
+    const nodeT = mesh.nodeTransform
+    if (nodeT) {
+      const numVerts = mesh.vertexCount
+      vertices = new Float32Array(numVerts * 3)
+      
+      const scale = nodeT.scale || [1, 1, 1]
+      const translation = nodeT.translation || [0, 0, 0]
+      const rotation = nodeT.rotation
+      
+      for (let i = 0; i < numVerts; i++) {
+        let x = mesh.vertices[i * 3] * scale[0]
+        let y = mesh.vertices[i * 3 + 1] * scale[1]
+        let z = mesh.vertices[i * 3 + 2] * scale[2]
+        
+        if (rotation) {
+          const [qx, qy, qz, qw] = rotation
+          const ix = qw * x + qy * z - qz * y
+          const iy = qw * y + qz * x - qx * z
+          const iz = qw * z + qx * y - qy * x
+          const iw = -qx * x - qy * y - qz * z
+          x = ix * qw - iw * qx - iy * qz + iz * qy
+          y = iy * qw - iw * qy - iz * qx + ix * qz
+          z = iz * qw - iw * qz - ix * qy + iy * qx
+        }
+        
+        vertices[i * 3] = x + translation[0]
+        vertices[i * 3 + 1] = y + translation[1]
+        vertices[i * 3 + 2] = z + translation[2]
+      }
+    }
+    
     const triangles = new J.TriangleList(); triangles.resize(mesh.triangleCount)
+    const f3 = new J.Float3(0, 0, 0)
     for (let t = 0; t < mesh.triangleCount; t++) {
       const tri = triangles.at(t)
       for (let v = 0; v < 3; v++) {
         const idx = mesh.indices[t * 3 + v]
-        tri.set_mV(v, new J.Float3(mesh.vertices[idx * 3], mesh.vertices[idx * 3 + 1], mesh.vertices[idx * 3 + 2]))
+        f3.x = vertices[idx * 3]; f3.y = vertices[idx * 3 + 1]; f3.z = vertices[idx * 3 + 2]
+        tri.set_mV(v, f3)
       }
     }
-    const shape = new J.MeshShapeSettings(triangles).Create().Get()
+    const settings = new J.MeshShapeSettings(triangles)
+    const shape = settings.Create().Get()
+    J.destroy(f3)
+    J.destroy(triangles)
+    J.destroy(settings)
     return this._addBody(shape, [0, 0, 0], J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', mesh: mesh.name, triangles: mesh.triangleCount } })
   }
+
+  addStaticTrimeshAsync(glbPath, meshIndex = 0, position = [0, 0, 0]) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const J = this.Jolt
+        // Use combined extraction: all meshes + all primitives (handles Draco, multi-mesh maps)
+        const mesh = await extractAllMeshesFromGLBAsync(glbPath)
+        const { vertices, indices, triangleCount } = mesh
+
+        const triangles = new J.TriangleList(); triangles.resize(triangleCount)
+        // Reuse a single Float3 to avoid WASM heap growth from per-vertex allocations
+        const f3 = new J.Float3(0, 0, 0)
+        for (let t = 0; t < triangleCount; t++) {
+          const tri = triangles.at(t)
+          for (let v = 0; v < 3; v++) {
+            const idx = indices[t * 3 + v]
+            f3.x = vertices[idx * 3]; f3.y = vertices[idx * 3 + 1]; f3.z = vertices[idx * 3 + 2]
+            tri.set_mV(v, f3)
+          }
+        }
+        const settings = new J.MeshShapeSettings(triangles)
+        const shape = settings.Create().Get()
+        J.destroy(f3)
+        J.destroy(triangles)
+        J.destroy(settings)
+        const id = this._addBody(shape, position, J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', triangles: triangleCount } })
+        resolve(id)
+      } catch (e) {
+        reject(e)
+      }
+    })
+  }
   addPlayerCharacter(radius, halfHeight, position, mass) {
     const J = this.Jolt
     const cvs = new J.CharacterVirtualSettings()
@@ -142,9 +214,7 @@ export class PhysicsWorld {
   getCharacterPosition(charId) {
     const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
     const p = ch.GetPosition()
-    const r = [p.GetX(), p.GetY(), p.GetZ()]
-    this.Jolt.destroy(p)
-    return r
+    return [p.GetX(), p.GetY(), p.GetZ()]
   }
   getCharacterVelocity(charId) {
     const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
@@ -230,8 +300,8 @@ export class PhysicsWorld {
     const dir = len > 0 ? [direction[0] / len, direction[1] / len, direction[2] / len] : direction
     const ray = new J.RRayCast(new J.RVec3(origin[0], origin[1], origin[2]), new J.Vec3(dir[0] * maxDistance, dir[1] * maxDistance, dir[2] * maxDistance))
     const rs = new J.RayCastSettings(), col = new J.CastRayClosestHitCollisionCollector()
-    const bp = new J.DefaultBroadPhaseLayerFilter(this._ovbp)
-    const ol = new J.DefaultObjectLayerFilter(this._objFilter)
+    const bp = new J.DefaultBroadPhaseLayerFilter(this.jolt.GetObjectVsBroadPhaseLayerFilter(), LAYER_DYNAMIC)
+    const ol = new J.DefaultObjectLayerFilter(this.jolt.GetObjectLayerPairFilter(), LAYER_DYNAMIC)
     const eb = excludeBodyId != null ? this._getBody(excludeBodyId) : null
     const bf = eb ? new J.IgnoreSingleBodyFilter(eb.GetID()) : new J.BodyFilter()
     const sf = new J.ShapeFilter()
@@ -245,13 +315,25 @@ export class PhysicsWorld {
     return result
   }
   destroy() {
+    if (!this.Jolt) return
+    const J = this.Jolt
     if (this.characters) {
-      for (const [id, ch] of this.characters) {
-        this.Jolt.destroy(ch)
-      }
+      for (const ch of this.characters.values()) J.destroy(ch)
       this.characters.clear()
     }
+    if (this._charFilters) {
+      J.destroy(this._charFilters.bp)
+      J.destroy(this._charFilters.ol)
+      J.destroy(this._charFilters.body)
+      J.destroy(this._charFilters.shape)
+      this._charFilters = null
+    }
+    if (this._charUpdateSettings) { J.destroy(this._charUpdateSettings); this._charUpdateSettings = null }
+    if (this._charGravity) { J.destroy(this._charGravity); this._charGravity = null }
     for (const [id] of this.bodies) this.removeBody(id)
-    if (this.jolt) { this.Jolt.destroy(this.jolt); this.jolt = null }
+    if (this._tmpVec3) { J.destroy(this._tmpVec3); this._tmpVec3 = null }
+    if (this._tmpRVec3) { J.destroy(this._tmpRVec3); this._tmpRVec3 = null }
+    if (this.jolt) { J.destroy(this.jolt); this.jolt = null }
+    this.physicsSystem = null; this.bodyInterface = null
   }
 }

package/src/sdk/TickHandler.js

@@ -102,8 +102,7 @@ export function createTickHandler(deps) {
           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())
+            const { encoded, entityMap } = SnapshotEncoder.encodeDelta(combined, new Map())
             playerEntityMaps.set(player.id, entityMap)
             connections.send(player.id, MSG.SNAPSHOT, { seq: snapshotSeq, ...encoded })
           } else {

package/apps/arena/index.js

@@ -1,83 +0,0 @@
-const ASSET_BASE = 'https://raw.githubusercontent.com/anEntrypoint/assets/main'
-
-const JUNK_MODELS = [
-  `${ASSET_BASE}/dumpster_b076662a_v1.glb`,
-  `${ASSET_BASE}/garbage_can_6b3d052b_v1.glb`,
-  `${ASSET_BASE}/fire_hydrant_ba0175c1_v1.glb`,
-  `${ASSET_BASE}/crushed_oil_barrel_e450f43f_v1.glb`,
-]
-
-const HALF = 12
-const WALL_H = 3
-const WALL_T = 0.5
-
-const WALLS = [
-  { id: 'arena-wall-n', x: 0,     y: WALL_H / 2, z: -HALF,  hx: HALF,        hy: WALL_H / 2, hz: WALL_T / 2 },
-  { id: 'arena-wall-s', x: 0,     y: WALL_H / 2, z:  HALF,  hx: HALF,        hy: WALL_H / 2, hz: WALL_T / 2 },
-  { id: 'arena-wall-e', x:  HALF, y: WALL_H / 2, z: 0,      hx: WALL_T / 2, hy: WALL_H / 2, hz: HALF },
-  { id: 'arena-wall-w', x: -HALF, y: WALL_H / 2, z: 0,      hx: WALL_T / 2, hy: WALL_H / 2, hz: HALF },
-]
-
-const PROPS = [
-  { model: 0, x: -6, z: -6, rot: 0.5 },
-  { model: 0, x:  7, z:  5, rot: 2.1 },
-  { model: 1, x: -8, z:  3, rot: 1.0 },
-  { model: 1, x:  5, z: -7, rot: 3.2 },
-  { model: 1, x:  3, z:  8, rot: 0.3 },
-  { model: 2, x: -4, z: -9, rot: 1.5 },
-  { model: 2, x:  9, z: -3, rot: 4.0 },
-  { model: 3, x: -7, z:  7, rot: 0.8 },
-  { model: 3, x:  6, z:  2, rot: 2.7 },
-  { model: 3, x: -3, z: -5, rot: 1.2 },
-]
-
-export default {
-  server: {
-    setup(ctx) {
-      ctx.state.ids = ctx.state.ids || []
-      if (ctx.state.ids.length > 0) return
-
-      // Ground (this entity itself)
-      ctx.entity.custom = { mesh: 'box', color: 0x5a7a4a, roughness: 1, sx: HALF * 2, sy: 0.5, sz: HALF * 2 }
-      ctx.physics.setStatic(true)
-      ctx.physics.addBoxCollider([HALF, 0.25, HALF])
-
-      // Walls - each gets box-static app which adds its own collider
-      for (const w of WALLS) {
-        const e = ctx.world.spawn(w.id, {
-          position: [w.x, w.y, w.z],
-          app: 'box-static',
-          config: { hx: w.hx, hy: w.hy, hz: w.hz, color: 0x7a6a5a, roughness: 0.9 }
-        })
-        if (e) ctx.state.ids.push(w.id)
-      }
-
-      // Props from remote asset repo (static, convex hull from model)
-      for (let i = 0; i < PROPS.length; i++) {
-        const p = PROPS[i]
-        const id = `arena-prop-${i}`
-        const a = p.rot / 2
-        const e = ctx.world.spawn(id, {
-          model: JUNK_MODELS[p.model],
-          position: [p.x, 0, p.z],
-          rotation: [0, Math.sin(a), 0, Math.cos(a)],
-          app: 'prop-static'
-        })
-        if (e) ctx.state.ids.push(id)
-      }
-
-      ctx.debug.log(`[arena] setup: ground + ${WALLS.length} walls + ${PROPS.length} props`)
-    },
-
-    teardown(ctx) {
-      for (const id of ctx.state.ids || []) ctx.world.destroy(id)
-      ctx.state.ids = []
-    }
-  },
-
-  client: {
-    render(ctx) {
-      return { position: ctx.entity.position, rotation: ctx.entity.rotation, custom: ctx.entity.custom }
-    }
-  }
-}