@lanmower/entrypoint 0.16.0

package/apps/world/index.js

@@ -0,0 +1,22 @@
+export default {
+  port: 8080,
+  tickRate: 128,
+  gravity: [0, -9.81, 0],
+  movement: {
+    maxSpeed: 8.0,
+    groundAccel: 10.0,
+    airAccel: 1.0,
+    friction: 7.2,
+    stopSpeed: 2.0,
+    jumpImpulse: 4.5,
+    collisionRestitution: 0.7,
+    collisionDamping: 0.5
+  },
+  entities: [
+    { id: 'environment', model: './world/schwust.glb', position: [0, 0, 0], app: 'environment' },
+    { id: 'game', position: [0, 0, 0], app: 'tps-game' },
+    { id: 'power-crates', position: [0, 0, 0], app: 'power-crate' }
+  ],
+  playerModel: './world/kaira.glb',
+  spawnPoint: [-35, 3, -65]
+}

package/client/app.js

@@ -0,0 +1,181 @@
+import * as THREE from 'three'
+import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'
+import { PhysicsNetworkClient, InputHandler, MSG } from '/src/index.client.js'
+import { createElement, applyDiff } from 'webjsx'
+import { createCameraController } from './camera.js'
+
+const scene = new THREE.Scene()
+scene.background = new THREE.Color(0x87ceeb)
+scene.fog = new THREE.Fog(0x87ceeb, 80, 200)
+const camera = new THREE.PerspectiveCamera(70, window.innerWidth / window.innerHeight, 0.1, 500)
+const renderer = new THREE.WebGLRenderer({ antialias: true })
+renderer.setSize(window.innerWidth, window.innerHeight)
+renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2))
+renderer.shadowMap.enabled = true
+renderer.shadowMap.type = THREE.PCFSoftShadowMap
+document.body.appendChild(renderer.domElement)
+
+scene.add(new THREE.AmbientLight(0xffffff, 0.6))
+const sun = new THREE.DirectionalLight(0xffffff, 1.0)
+sun.position.set(30, 50, 20)
+sun.castShadow = true
+sun.shadow.mapSize.set(2048, 2048)
+sun.shadow.camera.near = 0.5
+sun.shadow.camera.far = 200
+const sc = sun.shadow.camera
+sc.left = -80; sc.right = 80; sc.top = 80; sc.bottom = -80
+scene.add(sun)
+
+const ground = new THREE.Mesh(new THREE.PlaneGeometry(200, 200), new THREE.MeshStandardMaterial({ color: 0x444444 }))
+ground.rotation.x = -Math.PI / 2
+ground.receiveShadow = true
+scene.add(ground)
+
+const gltfLoader = new GLTFLoader()
+const playerMeshes = new Map()
+const entityMeshes = new Map()
+const appModules = new Map()
+const entityAppMap = new Map()
+const inputHandler = new InputHandler()
+const uiRoot = document.getElementById('ui-root')
+const clickPrompt = document.getElementById('click-prompt')
+const cam = createCameraController(camera, scene)
+cam.restore(JSON.parse(sessionStorage.getItem('cam') || 'null'))
+sessionStorage.removeItem('cam')
+let lastShootTime = 0
+let lastFrameTime = performance.now()
+
+function createPlayerMesh(id, isLocal) {
+  const group = new THREE.Group()
+  const body = new THREE.Mesh(new THREE.CapsuleGeometry(0.4, 1.0, 4, 8), new THREE.MeshStandardMaterial({ color: isLocal ? 0x00ff88 : 0xff4444 }))
+  body.position.y = 0.9; body.castShadow = true; group.add(body)
+  const head = new THREE.Mesh(new THREE.SphereGeometry(0.25, 8, 6), new THREE.MeshStandardMaterial({ color: isLocal ? 0x00cc66 : 0xcc3333 }))
+  head.position.y = 1.7; head.castShadow = true; group.add(head)
+  scene.add(group)
+  return group
+}
+
+function removePlayerMesh(id) {
+  const mesh = playerMeshes.get(id)
+  if (!mesh) return
+  scene.remove(mesh)
+  mesh.traverse(c => { if (c.geometry) c.geometry.dispose(); if (c.material) c.material.dispose() })
+  playerMeshes.delete(id)
+}
+
+function evaluateAppModule(code) {
+  try {
+    const stripped = code.replace(/^import\s+.*$/gm, '')
+    const wrapped = stripped.replace(/export\s+default\s+/, 'return ')
+    return new Function(wrapped)()
+  } catch (e) { console.error('[app-eval]', e.message); return null }
+}
+
+function loadEntityModel(entityId, entityState) {
+  if (!entityState.model) return
+  const url = entityState.model.startsWith('./') ? '/' + entityState.model.slice(2) : entityState.model
+  gltfLoader.load(url, (gltf) => {
+    const model = gltf.scene
+    model.position.set(...entityState.position)
+    if (entityState.rotation) model.quaternion.set(...entityState.rotation)
+    model.traverse(c => { if (c.isMesh) { c.castShadow = true; c.receiveShadow = true } })
+    scene.add(model)
+    entityMeshes.set(entityId, model)
+    scene.remove(ground)
+  }, undefined, (err) => console.error('[gltf]', entityId, err))
+}
+
+function renderAppUI(state) {
+  const uiFragments = []
+  for (const entity of state.entities) {
+    const appName = entityAppMap.get(entity.id)
+    if (!appName) continue
+    const appClient = appModules.get(appName)
+    if (!appClient?.render) continue
+    try {
+      const result = appClient.render({ entity, state: entity.custom || {}, h: createElement })
+      if (result?.ui) uiFragments.push({ id: entity.id, ui: result.ui })
+    } catch (e) { console.error('[ui]', entity.id, e.message) }
+  }
+  const local = state.players.find(p => p.id === client.playerId)
+  const hp = local?.health ?? 100
+  const hudVdom = createElement('div', { id: 'hud' },
+    createElement('div', { id: 'crosshair' }, '+'),
+    createElement('div', { id: 'health-bar' },
+      createElement('div', { id: 'health-fill', style: `width:${hp}%;background:${hp > 60 ? '#0f0' : hp > 30 ? '#ff0' : '#f00'}` }),
+      createElement('span', { id: 'health-text' }, String(hp))
+    ),
+    createElement('div', { id: 'info' }, `Players: ${state.players.length} | Tick: ${client.currentTick}`),
+    ...uiFragments.map(f => createElement('div', { 'data-app': f.id }, f.ui))
+  )
+  try { applyDiff(uiRoot, hudVdom) } catch (e) { console.error('[ui] diff:', e.message) }
+}
+
+const client = new PhysicsNetworkClient({
+  serverUrl: `ws://${window.location.host}/ws`,
+  onStateUpdate: (state) => {
+    for (const p of state.players) {
+      if (!playerMeshes.has(p.id)) playerMeshes.set(p.id, createPlayerMesh(p.id, p.id === client.playerId))
+      const mesh = playerMeshes.get(p.id)
+      mesh.position.set(p.position[0], p.position[1] - 1.3, p.position[2])
+      if (p.rotation) mesh.quaternion.set(...p.rotation)
+    }
+    renderAppUI(state)
+  },
+  onPlayerJoined: (id) => { if (!playerMeshes.has(id)) playerMeshes.set(id, createPlayerMesh(id, id === client.playerId)) },
+  onPlayerLeft: (id) => removePlayerMesh(id),
+  onEntityAdded: (id, state) => loadEntityModel(id, state),
+  onWorldDef: (wd) => { if (wd.entities) for (const e of wd.entities) { if (e.app) entityAppMap.set(e.id, e.app); if (e.model && !entityMeshes.has(e.id)) loadEntityModel(e.id, e) } },
+  onAppModule: (d) => { const a = evaluateAppModule(d.code); if (a?.client) appModules.set(d.app, a.client) },
+  onAssetUpdate: () => {},
+  onAppEvent: () => {},
+  onHotReload: () => { sessionStorage.setItem('cam', JSON.stringify(cam.save())); location.reload() },
+  debug: false
+})
+
+let inputLoopId = null
+function startInputLoop() {
+  if (inputLoopId) return
+  inputLoopId = setInterval(() => {
+    if (!client.connected) return
+    const input = inputHandler.getInput()
+    input.yaw = cam.yaw; input.pitch = cam.pitch
+    client.sendInput(input)
+    if (input.shoot && Date.now() - lastShootTime > 100) {
+      lastShootTime = Date.now()
+      const local = client.state?.players?.find(p => p.id === client.playerId)
+      if (local) {
+        const pos = local.position
+        client.sendFire({ origin: [pos[0], pos[1] + 0.9, pos[2]], direction: cam.getAimDirection(pos) })
+        const flash = new THREE.PointLight(0xffaa00, 3, 8)
+        flash.position.set(pos[0], pos[1] + 0.5, pos[2])
+        scene.add(flash)
+        setTimeout(() => scene.remove(flash), 60)
+      }
+    }
+  }, 1000 / 60)
+}
+
+renderer.domElement.addEventListener('click', () => { if (!document.pointerLockElement) renderer.domElement.requestPointerLock() })
+document.addEventListener('pointerlockchange', () => {
+  const locked = document.pointerLockElement === renderer.domElement
+  clickPrompt.style.display = locked ? 'none' : 'block'
+  if (locked) document.addEventListener('mousemove', cam.onMouseMove)
+  else document.removeEventListener('mousemove', cam.onMouseMove)
+})
+renderer.domElement.addEventListener('wheel', cam.onWheel, { passive: false })
+window.addEventListener('resize', () => { camera.aspect = window.innerWidth / window.innerHeight; camera.updateProjectionMatrix(); renderer.setSize(window.innerWidth, window.innerHeight) })
+
+function animate() {
+  requestAnimationFrame(animate)
+  const now = performance.now()
+  const frameDt = Math.min((now - lastFrameTime) / 1000, 0.1)
+  lastFrameTime = now
+  const local = client.state?.players?.find(p => p.id === client.playerId)
+  cam.update(local, playerMeshes.get(client.playerId), frameDt)
+  renderer.render(scene, camera)
+}
+animate()
+
+client.connect().then(() => { console.log('Connected'); startInputLoop() }).catch(err => console.error('Connection failed:', err))
+window.debug = { scene, camera, renderer, client, playerMeshes, entityMeshes, appModules, inputHandler }

package/client/camera.js

@@ -0,0 +1,116 @@
+import * as THREE from 'three'
+
+const camTarget = new THREE.Vector3()
+const camRaycaster = new THREE.Raycaster()
+const camDir = new THREE.Vector3()
+const camDesired = new THREE.Vector3()
+const camLookTarget = new THREE.Vector3()
+const aimRaycaster = new THREE.Raycaster()
+const aimDir = new THREE.Vector3()
+const shoulderOffset = 0.35
+const headHeight = 0.4
+const camFollowSpeed = 12.0
+const camSnapSpeed = 30.0
+const zoomStages = [0, 1.5, 3, 5, 8]
+
+export function createCameraController(camera, scene) {
+  let yaw = 0, pitch = 0, zoomIndex = 2, camInitialized = false
+
+  function restore(saved) {
+    if (saved) { yaw = saved.yaw || 0; pitch = saved.pitch || 0; zoomIndex = saved.zoomIndex ?? 2 }
+  }
+
+  function save() { return { yaw, pitch, zoomIndex } }
+
+  function onMouseMove(e) {
+    yaw -= e.movementX * 0.002
+    pitch -= e.movementY * 0.002
+    pitch = Math.max(-1.4, Math.min(1.4, pitch))
+  }
+
+  function onWheel(e) {
+    if (e.deltaY > 0) zoomIndex = Math.min(zoomIndex + 1, zoomStages.length - 1)
+    else zoomIndex = Math.max(zoomIndex - 1, 0)
+    e.preventDefault()
+  }
+
+  function getAimDirection(playerPos) {
+    const sy = Math.sin(yaw), cy = Math.cos(yaw)
+    const sp = Math.sin(pitch), cp = Math.cos(pitch)
+    const fwdX = sy * cp, fwdY = sp, fwdZ = cy * cp
+    if (!playerPos || zoomStages[zoomIndex] < 0.01) return [fwdX, fwdY, fwdZ]
+    const dist = zoomStages[zoomIndex]
+    const rightX = -cy, rightZ = sy
+    const cpx = playerPos[0] - fwdX * dist + rightX * shoulderOffset
+    const cpy = playerPos[1] + headHeight - fwdY * dist + 0.2
+    const cpz = playerPos[2] - fwdZ * dist + rightZ * shoulderOffset
+    const tx = cpx + fwdX * 200, ty = cpy + fwdY * 200, tz = cpz + fwdZ * 200
+    const ox = playerPos[0], oy = playerPos[1] + 0.9, oz = playerPos[2]
+    const dx = tx - ox, dy = ty - oy, dz = tz - oz
+    const len = Math.sqrt(dx * dx + dy * dy + dz * dz)
+    return len > 0.001 ? [dx / len, dy / len, dz / len] : [fwdX, fwdY, fwdZ]
+  }
+
+  function update(localPlayer, localMesh, frameDt) {
+    if (!localPlayer) return
+    const dist = zoomStages[zoomIndex]
+    camTarget.set(localPlayer.position[0], localPlayer.position[1] + headHeight, localPlayer.position[2])
+    if (localMesh) localMesh.visible = dist > 0.5
+    const sy = Math.sin(yaw), cy = Math.cos(yaw)
+    const sp = Math.sin(pitch), cp = Math.cos(pitch)
+    const fwdX = sy * cp, fwdY = sp, fwdZ = cy * cp
+    const rightX = -cy, rightZ = sy
+    if (dist < 0.01) {
+      camera.position.copy(camTarget)
+      camera.lookAt(camTarget.x + fwdX, camTarget.y + fwdY, camTarget.z + fwdZ)
+    } else {
+      camDesired.set(
+        camTarget.x - fwdX * dist + rightX * shoulderOffset,
+        camTarget.y - fwdY * dist + 0.2,
+        camTarget.z - fwdZ * dist + rightZ * shoulderOffset
+      )
+      camDir.subVectors(camDesired, camTarget).normalize()
+      const fullDist = camTarget.distanceTo(camDesired)
+      camRaycaster.set(camTarget, camDir)
+      camRaycaster.far = fullDist
+      camRaycaster.near = 0
+      const hits = camRaycaster.intersectObjects(scene.children, true)
+      let clippedDist = fullDist
+      for (const hit of hits) {
+        if (hit.object === localMesh || localMesh?.children?.includes(hit.object)) continue
+        if (hit.distance < clippedDist) clippedDist = hit.distance - 0.2
+      }
+      if (clippedDist < 0.3) clippedDist = 0.3
+      camDesired.set(
+        camTarget.x + camDir.x * clippedDist,
+        camTarget.y + camDir.y * clippedDist,
+        camTarget.z + camDir.z * clippedDist
+      )
+      if (!camInitialized) { camera.position.copy(camDesired); camInitialized = true }
+      else {
+        const closer = clippedDist < camera.position.distanceTo(camTarget)
+        const speed = closer ? camSnapSpeed : camFollowSpeed
+        camera.position.lerp(camDesired, 1.0 - Math.exp(-speed * frameDt))
+      }
+      aimDir.set(fwdX, fwdY, fwdZ)
+      aimRaycaster.set(camera.position, aimDir)
+      aimRaycaster.far = 500
+      aimRaycaster.near = 0.5
+      const aimHits = aimRaycaster.intersectObjects(scene.children, true)
+      let aimPoint = null
+      for (const ah of aimHits) {
+        if (ah.object === localMesh || localMesh?.children?.includes(ah.object)) continue
+        aimPoint = ah.point; break
+      }
+      if (aimPoint) {
+        if (!camLookTarget.lengthSq()) camLookTarget.copy(aimPoint)
+        camLookTarget.lerp(aimPoint, 1.0 - Math.exp(-camFollowSpeed * frameDt))
+      } else {
+        camLookTarget.set(camera.position.x + fwdX * 200, camera.position.y + fwdY * 200, camera.position.z + fwdZ * 200)
+      }
+      camera.lookAt(camLookTarget)
+    }
+  }
+
+  return { restore, save, onMouseMove, onWheel, getAimDirection, update, get yaw() { return yaw }, get pitch() { return pitch } }
+}

package/client/index.html

@@ -0,0 +1,24 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Hyperfy</title>
+  <link rel="stylesheet" href="/style.css">
+  <script type="importmap">
+  {
+    "imports": {
+      "three": "https://esm.sh/three@0.171.0",
+      "three/addons/": "https://esm.sh/three@0.171.0/examples/jsm/",
+      "webjsx": "/node_modules/webjsx/dist/index.js",
+      "webjsx/jsx-runtime": "/node_modules/webjsx/dist/jsx-runtime.js"
+    }
+  }
+  </script>
+</head>
+<body>
+  <div id="ui-root"></div>
+  <div id="click-prompt">Click to play</div>
+  <script type="module" src="/app.js"></script>
+</body>
+</html>

package/client/style.css

@@ -0,0 +1,11 @@
+* { margin: 0; padding: 0; box-sizing: border-box; }
+body { background: #000; color: #fff; overflow: hidden; font-family: monospace; }
+canvas { display: block; width: 100%; height: 100vh; }
+#ui-root { position: fixed; top: 0; left: 0; width: 100%; height: 100%; pointer-events: none; z-index: 10; }
+#hud { width: 100%; height: 100%; }
+#crosshair { position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); font-size: 24px; color: rgba(255,255,255,0.8); text-shadow: 0 0 2px #000; }
+#health-bar { position: absolute; bottom: 40px; left: 50%; transform: translateX(-50%); width: 200px; height: 8px; background: rgba(0,0,0,0.6); border: 1px solid rgba(255,255,255,0.3); }
+#health-fill { height: 100%; width: 100%; background: #0f0; transition: width 0.2s, background-color 0.2s; }
+#health-text { position: absolute; top: -20px; left: 50%; transform: translateX(-50%); font-size: 14px; color: #fff; text-shadow: 0 0 4px #000; }
+#info { position: absolute; top: 10px; left: 10px; font-size: 13px; line-height: 1.6; color: #0f0; text-shadow: 0 0 2px #000; }
+#click-prompt { position: absolute; top: 50%; left: 50%; transform: translate(-50%, 30px); font-size: 18px; color: rgba(255,255,255,0.7); text-shadow: 0 0 4px #000; z-index: 20; }

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@lanmower/entrypoint",
+  "version": "0.16.0",
+  "description": "Physics and netcode SDK for multiplayer game servers",
+  "type": "module",
+  "main": "src/index.js",
+  "bin": {
+    "entrypoint": "./server.js"
+  },
+  "scripts": {
+    "start": "node server.js"
+  },
+  "files": [
+    "src/",
+    "apps/",
+    "world/",
+    "client/",
+    "server.js",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "gamedev",
+    "multiplayer",
+    "physics",
+    "netcode",
+    "websocket",
+    "jolt-physics",
+    "game-server"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AnEntrypoint/entrypoint.git"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "d3-octree": "^1.1.0",
+    "jolt-physics": "^0.29.0",
+    "webjsx": "^0.0.73",
+    "ws": "^8.18.0"
+  },
+  "optionalDependencies": {
+    "@fails-components/webtransport": "^1.5.3",
+    "@fails-components/webtransport-transport-http3-quiche": "^1.5.3"
+  },
+  "devDependencies": {
+    "playwright": "^1.58.1"
+  }
+}

package/server.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { boot } from './src/sdk/server.js'
+await boot()

package/src/apps/AppContext.js

@@ -0,0 +1,172 @@
+import { CliDebugger } from '../debug/CliDebugger.js'
+
+export class AppContext {
+  constructor(entity, runtime) {
+    this._entity = entity
+    this._runtime = runtime
+    this._state = entity._appState || {}
+    entity._appState = this._state
+    this._entityProxy = this._buildEntityProxy()
+    this._debugger = new CliDebugger(`[${entity.id}]`)
+    this._busScope = runtime._eventBus ? runtime._eventBus.scope(entity.id) : null
+  }
+
+  _buildEntityProxy() {
+    const ent = this._entity
+    const runtime = this._runtime
+    return {
+      get id() { return ent.id },
+      get model() { return ent.model },
+      get position() { return ent.position },
+      set position(v) { ent.position = v },
+      get rotation() { return ent.rotation },
+      set rotation(v) { ent.rotation = v },
+      get scale() { return ent.scale },
+      set scale(v) { ent.scale = v },
+      get velocity() { return ent.velocity },
+      set velocity(v) { ent.velocity = v },
+      get custom() { return ent.custom },
+      set custom(v) { ent.custom = v },
+      get parent() { return ent.parent },
+      get children() { return [...ent.children] },
+      get worldTransform() { return runtime.getWorldTransform(ent.id) },
+      destroy: () => runtime.destroyEntity(ent.id)
+    }
+  }
+
+  get entity() { return this._entityProxy }
+
+  get physics() {
+    const ent = this._entity
+    const runtime = this._runtime
+    return {
+      setStatic: (v) => { ent.bodyType = v ? 'static' : ent.bodyType },
+      setDynamic: (v) => { ent.bodyType = v ? 'dynamic' : ent.bodyType },
+      setKinematic: (v) => { ent.bodyType = v ? 'kinematic' : ent.bodyType },
+      setMass: (v) => { ent.mass = v },
+      addBoxCollider: (s) => {
+        ent.collider = { type: 'box', size: s }
+        if (runtime._physics) {
+          const he = Array.isArray(s) ? s : [s, s, s]
+          const mt = ent.bodyType === 'dynamic' ? 'dynamic' : ent.bodyType === 'kinematic' ? 'kinematic' : 'static'
+          ent._physicsBodyId = runtime._physics.addBody('box', he, ent.position, mt, { rotation: ent.rotation, mass: ent.mass })
+        }
+      },
+      addSphereCollider: (r) => {
+        ent.collider = { type: 'sphere', radius: r }
+        if (runtime._physics) {
+          const mt = ent.bodyType === 'dynamic' ? 'dynamic' : ent.bodyType === 'kinematic' ? 'kinematic' : 'static'
+          ent._physicsBodyId = runtime._physics.addBody('sphere', r, ent.position, mt, { rotation: ent.rotation, mass: ent.mass })
+        }
+      },
+      addCapsuleCollider: (r, h) => {
+        ent.collider = { type: 'capsule', radius: r, height: h }
+        if (runtime._physics) {
+          const mt = ent.bodyType === 'dynamic' ? 'dynamic' : ent.bodyType === 'kinematic' ? 'kinematic' : 'static'
+          ent._physicsBodyId = runtime._physics.addBody('capsule', [r, h / 2], ent.position, mt, { rotation: ent.rotation, mass: ent.mass })
+        }
+      },
+      addMeshCollider: (m) => { ent.collider = { type: 'mesh', mesh: m } },
+      addTrimeshCollider: () => {
+        ent.collider = { type: 'trimesh', model: ent.model }
+        if (runtime._physics && ent.model) {
+          const bodyId = runtime._physics.addStaticTrimesh(ent.model, 0)
+          ent._physicsBodyId = bodyId
+        }
+      },
+      addForce: (f) => {
+        const mass = ent.mass || 1
+        ent.velocity[0] += f[0] / mass
+        ent.velocity[1] += f[1] / mass
+        ent.velocity[2] += f[2] / mass
+      },
+      setVelocity: (v) => { ent.velocity = [...v] }
+    }
+  }
+
+  get world() {
+    const runtime = this._runtime
+    return {
+      spawn: (id, cfg) => runtime.spawnEntity(id, cfg),
+      destroy: (id) => runtime.destroyEntity(id),
+      attach: (eid, app) => runtime.attachApp(eid, app),
+      detach: (eid) => runtime.detachApp(eid),
+      reparent: (eid, parentId) => runtime.reparent(eid, parentId),
+      query: (filter) => runtime.queryEntities(filter),
+      getEntity: (id) => runtime.getEntity(id),
+      nearby: (pos, radius) => runtime.nearbyEntities(pos, radius),
+      get gravity() { return runtime.gravity }
+    }
+  }
+
+  get players() {
+    const runtime = this._runtime
+    return {
+      getAll: () => runtime.getPlayers(),
+      getNearest: (pos, r) => runtime.getNearestPlayer(pos, r),
+      send: (pid, msg) => runtime.sendToPlayer(pid, msg),
+      broadcast: (msg) => runtime.broadcastToPlayers(msg),
+      setPosition: (pid, pos) => runtime.setPlayerPosition(pid, pos)
+    }
+  }
+
+  get time() {
+    const runtime = this._runtime
+    const entityId = this._entity.id
+    return {
+      get tick() { return runtime.currentTick },
+      get deltaTime() { return runtime.deltaTime },
+      get elapsed() { return runtime.elapsed },
+      after: (seconds, fn) => runtime.addTimer(entityId, seconds, fn, false),
+      every: (seconds, fn) => runtime.addTimer(entityId, seconds, fn, true)
+    }
+  }
+
+  get config() { return this._entity._config || {} }
+
+  get state() { return this._state }
+  set state(v) { Object.assign(this._state, v) }
+
+  get network() {
+    const runtime = this._runtime
+    return {
+      broadcast: (msg) => runtime.broadcastToPlayers(msg),
+      sendTo: (id, msg) => runtime.sendToPlayer(id, msg)
+    }
+  }
+
+  get bus() { return this._busScope }
+
+  get storage() {
+    const runtime = this._runtime
+    const entity = this._entity
+    const ns = entity._appName || entity.id
+    if (!runtime._storage) return null
+    const adapter = runtime._storage
+    return {
+      get: (key) => adapter.get(`${ns}/${key}`),
+      set: (key, value) => adapter.set(`${ns}/${key}`, value),
+      delete: (key) => adapter.delete(`${ns}/${key}`),
+      list: (prefix = '') => adapter.list(`${ns}/${prefix}`),
+      has: (key) => adapter.has(`${ns}/${key}`)
+    }
+  }
+
+  get debug() { return this._debugger }
+
+  get collider() {
+    const ent = this._entity
+    return {
+      box: (hx, hy, hz) => { ent.collider = { type: 'box', halfExtents: [hx, hy, hz] } },
+      capsule: (r, h) => { ent.collider = { type: 'capsule', radius: r, halfHeight: h } },
+      sphere: (r) => { ent.collider = { type: 'sphere', radius: r } }
+    }
+  }
+
+  raycast(origin, direction, maxDistance = 1000) {
+    if (this._runtime._physics) {
+      return this._runtime._physics.raycast(origin, direction, maxDistance)
+    }
+    return { hit: false, distance: maxDistance, body: null, position: null }
+  }
+}