@lanmower/entrypoint 0.16.0

package/src/apps/AppLoader.js

@@ -0,0 +1,160 @@
+import { readdir, readFile, watch, access } from 'node:fs/promises'
+import { join, basename, extname, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+const BLOCKED_PATTERNS = [
+  'process.exit', 'child_process', 'require(', '__proto__',
+  'Object.prototype', 'globalThis', 'eval(', 'import('
+]
+
+export class AppLoader {
+  constructor(runtime, config = {}) {
+    this._runtime = runtime
+    this._dir = config.dir || './apps'
+    this._watchers = new Map()
+    this._loaded = new Map()
+    this._onReloadCallback = null
+  }
+
+  async _resolvePath(name) {
+    const flat = join(this._dir, `${name}.js`)
+    try { await access(flat); return flat } catch {}
+    const folder = join(this._dir, name, 'index.js')
+    try { await access(folder); return folder } catch {}
+    return null
+  }
+
+  async loadAll() {
+    const entries = await readdir(this._dir, { withFileTypes: true }).catch(() => [])
+    const results = []
+    for (const entry of entries) {
+      let name = null
+      if (entry.isFile() && entry.name.endsWith('.js')) {
+        name = basename(entry.name, extname(entry.name))
+      } else if (entry.isDirectory()) {
+        try { await access(join(this._dir, entry.name, 'index.js')); name = entry.name } catch {}
+      }
+      if (name) {
+        const loaded = await this.loadApp(name)
+        if (loaded) results.push(name)
+      }
+    }
+    return results
+  }
+
+  async loadApp(name) {
+    const filePath = await this._resolvePath(name)
+    if (!filePath) return null
+    try {
+      const source = await readFile(filePath, 'utf-8')
+      if (!this._validate(source, name)) return null
+      const appDef = await this._evaluate(source, filePath)
+      if (!appDef) return null
+      this._runtime.registerApp(name, appDef)
+      this._loaded.set(name, { filePath, source, clientCode: source })
+      return appDef
+    } catch (e) {
+      console.error(`[AppLoader] failed to load "${name}": ${e.message}\n  file: ${filePath}\n  stack: ${e.stack?.split('\n').slice(1, 3).join('\n  ') || 'none'}`)
+      return null
+    }
+  }
+
+  _validate(source, name) {
+    for (const pattern of BLOCKED_PATTERNS) {
+      if (source.includes(pattern)) {
+        console.error(`[AppLoader] blocked pattern "${pattern}" in ${name}`)
+        return false
+      }
+    }
+    return true
+  }
+
+  async _evaluate(source, filePath) {
+    try {
+      const absPath = resolve(filePath)
+      const url = pathToFileURL(absPath).href + `?t=${Date.now()}`
+      const mod = await import(url)
+      return mod.default || mod
+    } catch (e) {
+      console.error(`[AppLoader] syntax/eval error in "${filePath}": ${e.message}\n  ${e.stack?.split('\n').slice(1, 3).join('\n  ') || ''}`)
+      return null
+    }
+  }
+
+  async watchAll() {
+    try {
+      const ac = new AbortController()
+      const watcher = watch(this._dir, { recursive: true, signal: ac.signal })
+      this._watchers.set('__dir__', ac)
+      ;(async () => {
+        try {
+          for await (const event of watcher) {
+            if (!event.filename || !event.filename.endsWith('.js')) continue
+            const parts = event.filename.replace(/\\/g, '/').split('/')
+            const name = parts.length > 1
+              ? parts[0]
+              : basename(event.filename, extname(event.filename))
+            await this._onFileChange(name)
+          }
+        } catch (e) {
+          if (e.name !== 'AbortError') {
+            console.error(`[AppLoader] watch error:`, e.message)
+          }
+        }
+      })()
+    } catch (e) {
+      console.error(`[AppLoader] watchAll error:`, e.message)
+    }
+  }
+
+  async _onFileChange(name) {
+    console.log(`[AppLoader] reloading ${name}`)
+    const appDef = await this.loadApp(name)
+    if (appDef) {
+      const cb = this._onReloadCallback ? (n, d) => {
+        this._onReloadCallback(n, this._loaded.get(n)?.clientCode)
+      } : null
+      this._runtime.queueReload(name, appDef, cb)
+      console.log(`[AppLoader] queued hot reload ${name}`)
+    }
+  }
+
+  stopWatching() {
+    for (const ac of this._watchers.values()) {
+      ac.abort()
+    }
+    this._watchers.clear()
+  }
+
+  getLoaded() {
+    return Array.from(this._loaded.keys())
+  }
+
+  getClientModules() {
+    const modules = {}
+    for (const [name, data] of this._loaded) {
+      if (data.clientCode) modules[name] = data.clientCode
+    }
+    return modules
+  }
+
+  getClientModule(name) {
+    return this._loaded.get(name)?.clientCode || null
+  }
+
+  async loadFromString(name, source) {
+    if (!this._validate(source, name)) return null
+    try {
+      const fn = new Function('exports', source + '\nreturn exports;')
+      const exports = {}
+      const result = fn(exports)
+      const appDef = result.default || result
+      this._runtime.registerApp(name, appDef)
+      this._loaded.set(name, { source, filePath: null })
+      return appDef
+    } catch (e) {
+      console.error(`[AppLoader] string eval error:`, e.message)
+      return null
+    }
+  }
+}

package/src/apps/AppRuntime.js

@@ -0,0 +1,192 @@
+import { AppContext } from './AppContext.js'
+import { HotReloadQueue } from './HotReloadQueue.js'
+import { EventBus } from './EventBus.js'
+import { mulQuat, rotVec } from '../math.js'
+import { MSG } from '../protocol/MessageTypes.js'
+
+export class AppRuntime {
+  constructor(c = {}) {
+    this.entities = new Map(); this.apps = new Map(); this.contexts = new Map()
+    this.gravity = c.gravity || [0, -9.81, 0]
+    this.currentTick = 0; this.deltaTime = 0; this.elapsed = 0
+    this._playerManager = c.playerManager || null; this._physics = c.physics || null; this._physicsIntegration = c.physicsIntegration || null
+    this._connections = c.connections || null; this._stageLoader = c.stageLoader || null
+    this._nextEntityId = 1; this._appDefs = new Map(); this._timers = new Map()
+    this._hotReload = new HotReloadQueue(this)
+    this._eventBus = c.eventBus || new EventBus()
+    this._eventLog = c.eventLog || null
+    this._storage = c.storage || null
+    this._eventBus.on('*', (event) => {
+      if (event.channel.startsWith('system.')) return
+      this._log('bus_event', { channel: event.channel, data: event.data }, event.meta)
+    })
+    this._eventBus.on('system.handover', (event) => {
+      const { targetEntityId, stateData } = event.data || {}
+      if (targetEntityId) this.fireEvent(targetEntityId, 'onHandover', event.meta.sourceEntity, stateData)
+    })
+  }
+
+  registerApp(name, appDef) { this._appDefs.set(name, appDef) }
+
+  spawnEntity(id, config = {}) {
+    const entityId = id || `entity_${this._nextEntityId++}`
+    const entity = {
+      id: entityId, model: config.model || null,
+      position: config.position ? [...config.position] : [0, 0, 0],
+      rotation: config.rotation || [0, 0, 0, 1],
+      scale: config.scale ? [...config.scale] : [1, 1, 1],
+      velocity: [0, 0, 0], mass: 1, bodyType: 'static', collider: null,
+      parent: null, children: new Set(),
+      _appState: null, _appName: config.app || null, _config: config.config || null, custom: null
+    }
+    this.entities.set(entityId, entity)
+    this._log('entity_spawn', { id: entityId, config }, { sourceEntity: entityId })
+    if (config.parent) {
+      const p = this.entities.get(config.parent)
+      if (p) { entity.parent = config.parent; p.children.add(entityId) }
+    }
+    if (config.autoTrimesh && entity.model && this._physics) {
+      entity.collider = { type: 'trimesh', model: entity.model }
+      entity._physicsBodyId = this._physics.addStaticTrimesh(entity.model, 0)
+    }
+    if (config.app) this._attachApp(entityId, config.app)
+    this._spatialInsert(entity)
+    return entity
+  }
+
+  _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})`)
+  }
+
+  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) }
+  getEntityWithApp(eid) { const e = this.entities.get(eid); return { entity: e, appName: e?._appName, hasApp: !!e?._appName } }
+
+  detachApp(entityId) {
+    const appDef = this.apps.get(entityId), ctx = this.contexts.get(entityId)
+    if (appDef && ctx) this._safeCall(appDef.server || appDef, 'teardown', [ctx], 'teardown')
+    this._eventBus.destroyScope(entityId)
+    this.clearTimers(entityId); this.apps.delete(entityId); this.contexts.delete(entityId)
+  }
+
+  destroyEntity(entityId) {
+    const entity = this.entities.get(entityId); if (!entity) return
+    this._log('entity_destroy', { id: entityId }, { sourceEntity: entityId })
+    for (const childId of [...entity.children]) this.destroyEntity(childId)
+    if (entity.parent) { const p = this.entities.get(entity.parent); if (p) p.children.delete(entityId) }
+    this._eventBus.destroyScope(entityId)
+    this.detachApp(entityId); this._spatialRemove(entityId); this.entities.delete(entityId)
+  }
+
+  reparent(entityId, newParentId) {
+    const e = this.entities.get(entityId); if (!e) return
+    if (e.parent) { const old = this.entities.get(e.parent); if (old) old.children.delete(entityId) }
+    e.parent = null
+    if (newParentId) { const np = this.entities.get(newParentId); if (np) { e.parent = newParentId; np.children.add(entityId) } }
+  }
+
+  getWorldTransform(entityId) {
+    const e = this.entities.get(entityId); if (!e) return null
+    const local = { position: [...e.position], rotation: [...e.rotation], scale: [...e.scale] }
+    if (!e.parent) return local
+    const pt = this.getWorldTransform(e.parent); if (!pt) return local
+    const sp = [e.position[0]*pt.scale[0], e.position[1]*pt.scale[1], e.position[2]*pt.scale[2]]
+    const rp = rotVec(sp, pt.rotation)
+    return { position: [pt.position[0]+rp[0], pt.position[1]+rp[1], pt.position[2]+rp[2]], rotation: mulQuat(pt.rotation, e.rotation), scale: [pt.scale[0]*e.scale[0], pt.scale[1]*e.scale[1], pt.scale[2]*e.scale[2]] }
+  }
+
+  tick(tickNum, dt) {
+    this.currentTick = tickNum; this.deltaTime = dt; this.elapsed += dt
+    for (const [entityId, appDef] of this.apps) {
+      const ctx = this.contexts.get(entityId); if (!ctx) continue
+      this._safeCall(appDef.server || appDef, 'update', [ctx, dt], `update(${entityId})`)
+    }
+    this._tickTimers(dt); this._spatialSync(); this._tickCollisions()
+  }
+
+  _encodeEntity(id, e) {
+    const r = Array.isArray(e.rotation) ? [...e.rotation] : [e.rotation.x || 0, e.rotation.y || 0, e.rotation.z || 0, e.rotation.w || 1]
+    return { id, model: e.model, position: [...e.position], rotation: r, scale: [...e.scale], bodyType: e.bodyType, custom: e.custom || null, parent: e.parent || null }
+  }
+
+  getSnapshot() {
+    const entities = []
+    for (const [id, e] of this.entities) entities.push(this._encodeEntity(id, e))
+    return { tick: this.currentTick, timestamp: Date.now(), entities }
+  }
+
+  getSnapshotForPlayer(playerPosition, radius) {
+    const relevant = new Set(this.relevantEntities(playerPosition, radius))
+    const entities = []
+    for (const [id, e] of this.entities) { if (relevant.has(id)) entities.push(this._encodeEntity(id, e)) }
+    return { tick: this.currentTick, timestamp: Date.now(), entities }
+  }
+
+  queryEntities(f) { return f ? Array.from(this.entities.values()).filter(f) : Array.from(this.entities.values()) }
+  getEntity(id) { return this.entities.get(id) || null }
+  fireEvent(eid, en, ...a) { const ad = this.apps.get(eid), c = this.contexts.get(eid); if (!ad || !c) return; this._log('app_event', { entityId: eid, event: en, args: a }, { sourceEntity: eid }); const s = ad.server || ad; if (s[en]) this._safeCall(s, en, [c, ...a], `${en}(${eid})`) }
+  fireInteract(eid, p) { this.fireEvent(eid, 'onInteract', p) }
+  fireMessage(eid, m) { this.fireEvent(eid, 'onMessage', m) }
+  addTimer(e, d, fn, r) { if (!this._timers.has(e)) this._timers.set(e, []); this._timers.get(e).push({ remaining: d, fn, repeat: r, interval: d }) }
+  clearTimers(eid) { this._timers.delete(eid) }
+
+  _tickTimers(dt) {
+    for (const [eid, timers] of this._timers) {
+      const keep = []
+      for (const t of timers) {
+        t.remaining -= dt
+        if (t.remaining <= 0) { try { t.fn() } catch (e) { console.error(`[AppRuntime] timer(${eid}):`, e.message) }; if (t.repeat) { t.remaining = t.interval; keep.push(t) } }
+        else keep.push(t)
+      }
+      if (keep.length) this._timers.set(eid, keep); else this._timers.delete(eid)
+    }
+  }
+
+  _tickCollisions() {
+    const c = Array.from(this.entities.values()).filter(e => e.collider && this.apps.has(e.id))
+    for (let i = 0; i < c.length; i++) for (let j = i + 1; j < c.length; j++) {
+      const a = c[i], b = c[j], d = Math.hypot(b.position[0]-a.position[0], b.position[1]-a.position[1], b.position[2]-a.position[2])
+      if (d < this._colR(a.collider) + this._colR(b.collider)) {
+        this.fireEvent(a.id, 'onCollision', { id: b.id, position: b.position, velocity: b.velocity })
+        this.fireEvent(b.id, 'onCollision', { id: a.id, position: a.position, velocity: a.velocity })
+      }
+    }
+  }
+
+  _colR(c) { return !c ? 0 : c.type === 'sphere' ? (c.radius||1) : c.type === 'capsule' ? Math.max(c.radius||0.5,(c.height||1)/2) : c.type === 'box' ? Math.max(...(c.size||c.halfExtents||[1,1,1])) : 1 }
+  setPlayerManager(pm) { this._playerManager = pm }
+  setStageLoader(sl) { this._stageLoader = sl }
+  getPlayers() { return this._playerManager ? this._playerManager.getConnectedPlayers() : [] }
+
+  getNearestPlayer(pos, r) {
+    let n = null, md = r * r
+    for (const p of this.getPlayers()) { const pp = p.state?.position; if (!pp) continue; const d = (pp[0]-pos[0])**2+(pp[1]-pos[1])**2+(pp[2]-pos[2])**2; if (d < md) { md = d; n = p } }
+    return n
+  }
+
+  broadcastToPlayers(m) { if (this._connections) this._connections.broadcast(MSG.APP_EVENT, m); else if (this._playerManager) this._playerManager.broadcast(m) }
+  sendToPlayer(id, m) { if (this._connections) this._connections.send(id, MSG.APP_EVENT, m); else if (this._playerManager) this._playerManager.sendToPlayer(id, m) }
+  setPlayerPosition(id, p) { this._physicsIntegration?.setPlayerPosition(id, p); if (this._playerManager) { const pl = this._playerManager.getPlayer(id); if (pl) pl.state.position = [...p] } }
+
+  queueReload(n, d, cb) { this._hotReload.enqueue(n, d, cb) }
+  _drainReloadQueue() { this._hotReload.drain() }
+  hotReload(n, d) { this._hotReload._execute(n, d) }
+
+  _spatialInsert(entity) {
+    if (!this._stageLoader) return; const stage = this._stageLoader.getActiveStage()
+    if (stage && !stage.hasEntity(entity.id)) { stage.entityIds.add(entity.id); stage.spatial.insert(entity.id, entity.position); if (entity.bodyType === 'static') stage._staticIds.add(entity.id) }
+  }
+  _spatialRemove(entityId) { if (!this._stageLoader) return; const stage = this._stageLoader.getActiveStage(); if (stage) { stage.spatial.remove(entityId); stage._staticIds.delete(entityId); stage.entityIds.delete(entityId) } }
+  _spatialSync() { if (this._stageLoader) this._stageLoader.syncAllPositions() }
+  nearbyEntities(position, radius) { if (!this._stageLoader) return Array.from(this.entities.keys()); return this._stageLoader.getNearbyEntities(position, radius) }
+  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  ') || ''}`) } }
+}

package/src/apps/EventBus.js

@@ -0,0 +1,62 @@
+export class EventBus {
+  constructor() {
+    this._handlers = new Map()
+    this._scoped = new Map()
+  }
+
+  on(channel, handler) {
+    if (!this._handlers.has(channel)) this._handlers.set(channel, new Set())
+    this._handlers.get(channel).add(handler)
+    return () => this.off(channel, handler)
+  }
+
+  off(channel, handler) {
+    const set = this._handlers.get(channel)
+    if (set) { set.delete(handler); if (set.size === 0) this._handlers.delete(channel) }
+  }
+
+  once(channel, handler) {
+    const wrapper = (...args) => { this.off(channel, wrapper); handler(...args) }
+    wrapper._original = handler
+    this.on(channel, wrapper)
+  }
+
+  emit(channel, data, meta = {}) {
+    const event = { channel, data, meta: { ...meta, timestamp: Date.now() } }
+    const exact = this._handlers.get(channel)
+    if (exact) for (const fn of exact) { try { fn(event) } catch (e) { console.error(`[EventBus] ${channel}:`, e.message) } }
+    for (const [pattern, handlers] of this._handlers) {
+      if (pattern === channel || !pattern.endsWith('*')) continue
+      const prefix = pattern.slice(0, -1)
+      if (channel.startsWith(prefix)) {
+        for (const fn of handlers) { try { fn(event) } catch (e) { console.error(`[EventBus] ${pattern}:`, e.message) } }
+      }
+    }
+    return event
+  }
+
+  scope(entityId) {
+    const unsubs = []
+    const scoped = {
+      on: (ch, fn) => { const u = this.on(ch, fn); unsubs.push(u); return u },
+      off: (ch, fn) => this.off(ch, fn),
+      once: (ch, fn) => { const wrapper = (...a) => { this.off(ch, wrapper); fn(...a) }; wrapper._original = fn; const u = this.on(ch, wrapper); unsubs.push(u); return u },
+      emit: (ch, data, meta = {}) => this.emit(ch, data, { ...meta, sourceEntity: entityId }),
+      handover: (targetEntityId, stateData) => this.emit('system.handover', { targetEntityId, stateData }, { sourceEntity: entityId }),
+      destroy: () => { for (const u of unsubs) u(); unsubs.length = 0 }
+    }
+    this._scoped.set(entityId, scoped)
+    return scoped
+  }
+
+  destroyScope(entityId) {
+    const scoped = this._scoped.get(entityId)
+    if (scoped) { scoped.destroy(); this._scoped.delete(entityId) }
+  }
+
+  clear() {
+    for (const scoped of this._scoped.values()) scoped.destroy()
+    this._scoped.clear()
+    this._handlers.clear()
+  }
+}

package/src/apps/HotReloadQueue.js

@@ -0,0 +1,63 @@
+import { AppContext } from './AppContext.js'
+
+export class HotReloadQueue {
+  constructor(runtime) {
+    this._runtime = runtime
+    this._queue = []
+    this._inProgress = false
+  }
+
+  enqueue(name, def, callback) {
+    this._queue.push({ name, def, callback })
+  }
+
+  drain() {
+    if (this._inProgress || this._queue.length === 0) return
+    this._inProgress = true
+    try {
+      while (this._queue.length > 0) {
+        const { name, def, callback } = this._queue.shift()
+        try {
+          this._execute(name, def)
+          this._resetHeartbeats()
+          if (callback) {
+            try { callback(name, def) } catch (e) {
+              console.error(`[HotReloadQueue] callback error:`, e.message)
+            }
+          }
+        } catch (e) {
+          console.error(`[HotReloadQueue] hotReload(${name}) error:`, e.message)
+        }
+      }
+    } finally {
+      this._inProgress = false
+    }
+  }
+
+  _execute(name, def) {
+    const rt = this._runtime
+    rt._appDefs.set(name, def)
+    for (const [eid, ent] of rt.entities) {
+      if (ent._appName !== name) continue
+      const old = rt.apps.get(eid), oldCtx = rt.contexts.get(eid)
+      if (old && oldCtx) rt._safeCall(old.server || old, 'teardown', [oldCtx], 'teardown')
+      rt.clearTimers(eid)
+      const ctx = new AppContext(ent, rt)
+      rt.contexts.set(eid, ctx)
+      rt.apps.set(eid, def)
+      rt._safeCall(def.server || def, 'setup', [ctx], `hotReload(${name})`)
+    }
+  }
+
+  _resetHeartbeats() {
+    const conn = this._runtime._connections
+    if (!conn) return
+    for (const client of conn.clients.values()) {
+      client.lastHeartbeat = Date.now()
+    }
+  }
+
+  get pending() {
+    return this._queue.length
+  }
+}

package/src/client/InputHandler.js

@@ -0,0 +1,85 @@
+export class InputHandler {
+  constructor(config = {}) {
+    this.keys = new Map()
+    this.mouseX = 0
+    this.mouseY = 0
+    this.mouseDown = false
+    this.callbacks = []
+    this.enabled = true
+
+    if (config.enableKeyboard !== false) {
+      this.setupKeyboardListeners()
+    }
+
+    if (config.enableMouse !== false) {
+      this.setupMouseListeners()
+    }
+  }
+
+  setupKeyboardListeners() {
+    if (typeof window === 'undefined') return
+
+    window.addEventListener('keydown', (e) => {
+      this.keys.set(e.key.toLowerCase(), true)
+    })
+
+    window.addEventListener('keyup', (e) => {
+      this.keys.set(e.key.toLowerCase(), false)
+    })
+  }
+
+  setupMouseListeners() {
+    if (typeof window === 'undefined') return
+
+    document.addEventListener('mousemove', (e) => {
+      this.mouseX = e.clientX
+      this.mouseY = e.clientY
+    })
+
+    document.addEventListener('mousedown', (e) => {
+      this.mouseDown = true
+    })
+
+    document.addEventListener('mouseup', (e) => {
+      this.mouseDown = false
+    })
+  }
+
+  getInput() {
+    if (!this.enabled) {
+      return {
+        forward: false,
+        backward: false,
+        left: false,
+        right: false,
+        jump: false,
+        shoot: this.mouseDown,
+        mouseX: this.mouseX,
+        mouseY: this.mouseY
+      }
+    }
+
+    return {
+      forward: this.keys.get('w') || this.keys.get('arrowup') || false,
+      backward: this.keys.get('s') || this.keys.get('arrowdown') || false,
+      left: this.keys.get('a') || this.keys.get('arrowleft') || false,
+      right: this.keys.get('d') || this.keys.get('arrowright') || false,
+      jump: this.keys.get(' ') || false,
+      shoot: this.mouseDown,
+      mouseX: this.mouseX,
+      mouseY: this.mouseY
+    }
+  }
+
+  onInput(callback) {
+    this.callbacks.push(callback)
+  }
+
+  enable() {
+    this.enabled = true
+  }
+
+  disable() {
+    this.enabled = false
+  }
+}