@lanmower/entrypoint 0.16.0

package/src/netcode/TickSystem.js

@@ -0,0 +1,66 @@
+export class TickSystem {
+  constructor(tickRate = 128) {
+    this.tickRate = tickRate
+    this.tickDuration = 1000 / tickRate
+    this.currentTick = 0
+    this.lastTickTime = 0
+    this.callbacks = []
+    this.running = false
+    this._reloadLocked = false
+    this._reloadResolve = null
+    this._tickInProgress = false
+  }
+
+  onTick(callback) {
+    this.callbacks.push(callback)
+  }
+
+  start() {
+    if (this.running) return
+    this.running = true
+    this.lastTickTime = Date.now()
+    this.loop()
+  }
+
+  loop() {
+    if (!this.running) return
+    const now = Date.now()
+    const elapsed = now - this.lastTickTime
+    if (elapsed >= this.tickDuration && !this._reloadLocked) {
+      this._tickInProgress = true
+      this.currentTick++
+      this.lastTickTime = now
+      for (const callback of this.callbacks) {
+        callback(this.currentTick, this.tickDuration / 1000)
+      }
+      this._tickInProgress = false
+      if (this._reloadResolve) {
+        this._reloadResolve()
+        this._reloadResolve = null
+      }
+    }
+    setImmediate(() => this.loop())
+  }
+
+  pauseForReload() {
+    this._reloadLocked = true
+    if (!this._tickInProgress) return Promise.resolve()
+    return new Promise(resolve => { this._reloadResolve = resolve })
+  }
+
+  resumeAfterReload() {
+    this._reloadLocked = false
+  }
+
+  stop() {
+    this.running = false
+  }
+
+  getTick() {
+    return this.currentTick
+  }
+
+  getTickDuration() {
+    return this.tickDuration / 1000
+  }
+}

package/src/physics/GLBLoader.js

@@ -0,0 +1,29 @@
+import { readFileSync } from 'node:fs'
+
+export function extractMeshFromGLB(filepath, meshIndex = 0) {
+  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 mesh = json.meshes[meshIndex]
+  if (!mesh) throw new Error(`Mesh index ${meshIndex} not found`)
+  const prim = mesh.primitives[0]
+  const posAcc = json.accessors[prim.attributes.POSITION]
+  const posView = json.bufferViews[posAcc.bufferView]
+  const posOff = binOffset + (posView.byteOffset || 0) + (posAcc.byteOffset || 0)
+  const vertices = new Float32Array(buf.buffer.slice(buf.byteOffset + posOff, buf.byteOffset + posOff + posAcc.count * 12))
+  let indices = null
+  if (prim.indices !== undefined) {
+    const idxAcc = json.accessors[prim.indices]
+    const idxView = json.bufferViews[idxAcc.bufferView]
+    const idxOff = binOffset + (idxView.byteOffset || 0) + (idxAcc.byteOffset || 0)
+    if (idxAcc.componentType === 5123) {
+      const raw = new Uint16Array(buf.buffer.slice(buf.byteOffset + idxOff, buf.byteOffset + idxOff + idxAcc.count * 2))
+      indices = new Uint32Array(raw)
+    } else {
+      indices = new Uint32Array(buf.buffer.slice(buf.byteOffset + idxOff, buf.byteOffset + idxOff + idxAcc.count * 4))
+    }
+  }
+  return { vertices, indices, vertexCount: posAcc.count, triangleCount: indices ? indices.length / 3 : 0, name: mesh.name }
+}

package/src/physics/World.js

@@ -0,0 +1,195 @@
+import initJolt from 'jolt-physics/wasm-compat'
+import { extractMeshFromGLB } 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 }
+export class PhysicsWorld {
+  constructor(config = {}) {
+    this.gravity = config.gravity || [0, -9.81, 0]
+    this.Jolt = null; this.jolt = null; this.physicsSystem = null; this.bodyInterface = null
+    this.bodies = new Map(); this.bodyMeta = new Map()
+    this._objFilter = null; this._ovbp = null
+  }
+  async init() {
+    const J = await getJolt()
+    this.Jolt = J
+    const settings = new J.JoltSettings()
+    const objFilter = new J.ObjectLayerPairFilterTable(NUM_LAYERS)
+    objFilter.EnableCollision(LAYER_STATIC, LAYER_DYNAMIC); objFilter.EnableCollision(LAYER_DYNAMIC, LAYER_DYNAMIC)
+    const bpI = new J.BroadPhaseLayerInterfaceTable(NUM_LAYERS, 2)
+    bpI.MapObjectToBroadPhaseLayer(LAYER_STATIC, new J.BroadPhaseLayer(0))
+    bpI.MapObjectToBroadPhaseLayer(LAYER_DYNAMIC, new J.BroadPhaseLayer(1))
+    const ovbp = new J.ObjectVsBroadPhaseLayerFilterTable(bpI, 2, objFilter, NUM_LAYERS)
+    settings.mObjectLayerPairFilter = objFilter; settings.mBroadPhaseLayerInterface = bpI
+    settings.mObjectVsBroadPhaseLayerFilter = ovbp
+    this._objFilter = objFilter; this._ovbp = ovbp
+    this.jolt = new J.JoltInterface(settings); J.destroy(settings)
+    this.physicsSystem = this.jolt.GetPhysicsSystem(); this.bodyInterface = this.physicsSystem.GetBodyInterface()
+    const [gx, gy, gz] = this.gravity
+    this.physicsSystem.SetGravity(new J.Vec3(gx, gy, gz))
+    return this
+  }
+  _addBody(shape, position, motionType, layer, opts = {}) {
+    const J = this.Jolt
+    const pos = new J.RVec3(position[0], position[1], position[2])
+    const rot = opts.rotation ? new J.Quat(...opts.rotation) : new J.Quat(0, 0, 0, 1)
+    const cs = new J.BodyCreationSettings(shape, pos, rot, motionType, layer)
+    if (opts.mass) { cs.mMassPropertiesOverride.mMass = opts.mass; cs.mOverrideMassProperties = J.EOverrideMassProperties_CalculateInertia }
+    if (opts.friction !== undefined) cs.mFriction = opts.friction
+    if (opts.restitution !== undefined) cs.mRestitution = opts.restitution
+    const activate = motionType === J.EMotionType_Static ? J.EActivation_DontActivate : J.EActivation_Activate
+    const body = this.bodyInterface.CreateBody(cs); this.bodyInterface.AddBody(body.GetID(), activate)
+    J.destroy(cs)
+    const id = body.GetID().GetIndexAndSequenceNumber()
+    this.bodies.set(id, body); this.bodyMeta.set(id, opts.meta || {})
+    return id
+  }
+  addStaticBox(halfExtents, position, rotation) {
+    const J = this.Jolt
+    const shape = new J.BoxShape(new J.Vec3(halfExtents[0], halfExtents[1], halfExtents[2]), 0.05, null)
+    return this._addBody(shape, position, J.EMotionType_Static, LAYER_STATIC, { rotation, meta: { type: 'static', shape: 'box' } })
+  }
+  addBody(shapeType, params, position, motionType, opts = {}) {
+    const J = this.Jolt
+    let shape, layer
+    if (shapeType === 'box') shape = new J.BoxShape(new J.Vec3(params[0], params[1], params[2]), 0.05, null)
+    else if (shapeType === 'sphere') shape = new J.SphereShape(params)
+    else if (shapeType === 'capsule') shape = new J.CapsuleShape(params[1], params[0])
+    else return null
+    const mt = motionType === 'dynamic' ? J.EMotionType_Dynamic : motionType === 'kinematic' ? J.EMotionType_Kinematic : J.EMotionType_Static
+    layer = motionType === 'static' ? LAYER_STATIC : LAYER_DYNAMIC
+    return this._addBody(shape, position, mt, layer, { ...opts, meta: { type: motionType, shape: shapeType } })
+  }
+  addStaticTrimesh(glbPath, meshIndex = 0) {
+    const J = this.Jolt
+    const mesh = extractMeshFromGLB(glbPath, meshIndex)
+    const triangles = new J.TriangleList(); triangles.resize(mesh.triangleCount)
+    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]))
+      }
+    }
+    const shape = new J.MeshShapeSettings(triangles).Create().Get()
+    return this._addBody(shape, [0, 0, 0], J.EMotionType_Static, LAYER_STATIC, { meta: { type: 'static', shape: 'trimesh', mesh: mesh.name, triangles: mesh.triangleCount } })
+  }
+  addPlayerCharacter(radius, halfHeight, position, mass) {
+    const J = this.Jolt
+    const cvs = new J.CharacterVirtualSettings()
+    cvs.mMass = mass || 80
+    cvs.mMaxSlopeAngle = 0.7854
+    cvs.mShape = new J.CapsuleShape(halfHeight, radius)
+    cvs.mBackFaceMode = J.EBackFaceMode_CollideWithBackFaces
+    cvs.mCharacterPadding = 0.02
+    cvs.mPenetrationRecoverySpeed = 1.0
+    cvs.mPredictiveContactDistance = 0.1
+    cvs.mSupportingVolume = new J.Plane(J.Vec3.prototype.sAxisY(), -radius)
+    const pos = new J.RVec3(position[0], position[1], position[2])
+    const ch = new J.CharacterVirtual(cvs, pos, J.Quat.prototype.sIdentity(), this.physicsSystem)
+    J.destroy(cvs)
+    if (!this._charFilters) {
+      this._charFilters = {
+        bp: new J.DefaultBroadPhaseLayerFilter(this.jolt.GetObjectVsBroadPhaseLayerFilter(), LAYER_DYNAMIC),
+        ol: new J.DefaultObjectLayerFilter(this.jolt.GetObjectLayerPairFilter(), LAYER_DYNAMIC),
+        body: new J.BodyFilter(),
+        shape: new J.ShapeFilter()
+      }
+      this._charUpdateSettings = new J.ExtendedUpdateSettings()
+      this._charUpdateSettings.mStickToFloorStepDown = new J.Vec3(0, -0.5, 0)
+      this._charUpdateSettings.mWalkStairsStepUp = new J.Vec3(0, 0.4, 0)
+      this._charGravity = new J.Vec3(this.gravity[0], this.gravity[1], this.gravity[2])
+    }
+    const id = this._nextCharId = (this._nextCharId || 0) + 1
+    if (!this.characters) this.characters = new Map()
+    this.characters.set(id, ch)
+    return id
+  }
+  updateCharacter(charId, dt) {
+    const ch = this.characters?.get(charId)
+    if (!ch) return
+    const f = this._charFilters
+    ch.ExtendedUpdate(dt, this._charGravity, this._charUpdateSettings, f.bp, f.ol, f.body, f.shape, this.jolt.GetTempAllocator())
+  }
+  getCharacterPosition(charId) {
+    const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
+    const p = ch.GetPosition(); return [p.GetX(), p.GetY(), p.GetZ()]
+  }
+  getCharacterVelocity(charId) {
+    const ch = this.characters?.get(charId); if (!ch) return [0, 0, 0]
+    const v = ch.GetLinearVelocity(); return [v.GetX(), v.GetY(), v.GetZ()]
+  }
+  setCharacterVelocity(charId, velocity) {
+    const ch = this.characters?.get(charId); if (!ch) return
+    ch.SetLinearVelocity(new this.Jolt.Vec3(velocity[0], velocity[1], velocity[2]))
+  }
+  setCharacterPosition(charId, position) {
+    const ch = this.characters?.get(charId); if (!ch) return
+    ch.SetPosition(new this.Jolt.RVec3(position[0], position[1], position[2]))
+  }
+  getCharacterGroundState(charId) {
+    const ch = this.characters?.get(charId); if (!ch) return false
+    return ch.GetGroundState() === this.Jolt.EGroundState_OnGround
+  }
+  removeCharacter(charId) {
+    if (!this.characters) return
+    this.characters.delete(charId)
+  }
+  _getBody(bodyId) { return this.bodies.get(bodyId) }
+  getBodyPosition(bodyId) {
+    const b = this._getBody(bodyId); if (!b) return [0, 0, 0]
+    const p = this.bodyInterface.GetPosition(b.GetID()); return [p.GetX(), p.GetY(), p.GetZ()]
+  }
+  getBodyRotation(bodyId) {
+    const b = this._getBody(bodyId); if (!b) return [0, 0, 0, 1]
+    const r = this.bodyInterface.GetRotation(b.GetID()); return [r.GetX(), r.GetY(), r.GetZ(), r.GetW()]
+  }
+  getBodyVelocity(bodyId) {
+    const b = this._getBody(bodyId); if (!b) return [0, 0, 0]
+    const v = this.bodyInterface.GetLinearVelocity(b.GetID()); return [v.GetX(), v.GetY(), v.GetZ()]
+  }
+  setBodyPosition(bodyId, position) {
+    const b = this._getBody(bodyId); if (!b) return
+    this.bodyInterface.SetPosition(b.GetID(), new this.Jolt.RVec3(position[0], position[1], position[2]), this.Jolt.EActivation_Activate)
+  }
+  setBodyVelocity(bodyId, velocity) {
+    const b = this._getBody(bodyId); if (!b) return
+    this.bodyInterface.SetLinearVelocity(b.GetID(), new this.Jolt.Vec3(velocity[0], velocity[1], velocity[2]))
+  }
+  addForce(bodyId, force) {
+    const b = this._getBody(bodyId); if (!b) return
+    this.bodyInterface.AddForce(b.GetID(), new this.Jolt.Vec3(force[0], force[1], force[2]))
+  }
+  addImpulse(bodyId, impulse) {
+    const b = this._getBody(bodyId); if (!b) return
+    this.bodyInterface.AddImpulse(b.GetID(), new this.Jolt.Vec3(impulse[0], impulse[1], impulse[2]))
+  }
+  step(deltaTime) { if (!this.jolt) return; this.jolt.Step(deltaTime, deltaTime > 1 / 55 ? 2 : 1) }
+  removeBody(bodyId) {
+    const b = this._getBody(bodyId); if (!b) return
+    this.bodyInterface.RemoveBody(b.GetID()); this.bodyInterface.DestroyBody(b.GetID())
+    this.bodies.delete(bodyId); this.bodyMeta.delete(bodyId)
+  }
+  raycast(origin, direction, maxDistance = 1000, excludeBodyId = null) {
+    if (!this.physicsSystem) return { hit: false, distance: maxDistance, body: null, position: null }
+    const J = this.Jolt
+    const len = Math.hypot(direction[0], direction[1], direction[2])
+    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, LAYER_DYNAMIC)
+    const ol = new J.DefaultObjectLayerFilter(this._objFilter, 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()
+    this.physicsSystem.GetNarrowPhaseQuery().CastRay(ray, rs, col, bp, ol, bf, sf)
+    let result
+    if (col.HadHit()) {
+      const dist = col.get_mHit().mFraction * maxDistance
+      result = { hit: true, distance: dist, body: null, position: [origin[0] + dir[0] * dist, origin[1] + dir[1] * dist, origin[2] + dir[2] * dist] }
+    } else { result = { hit: false, distance: maxDistance, body: null, position: null } }
+    J.destroy(ray); J.destroy(rs); J.destroy(col); J.destroy(bp); J.destroy(ol); J.destroy(bf); J.destroy(sf)
+    return result
+  }
+  destroy() { for (const [id] of this.bodies) this.removeBody(id); if (this.jolt) { this.Jolt.destroy(this.jolt); this.jolt = null } }
+}

package/src/protocol/Codec.js

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

package/src/protocol/EventEmitter.js

@@ -0,0 +1,60 @@
+export class EventEmitter {
+  constructor() {
+    this.listeners = new Map()
+  }
+
+  on(event, fn) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, [])
+    }
+    this.listeners.get(event).push(fn)
+    return this
+  }
+
+  off(event, fn) {
+    if (!this.listeners.has(event)) return this
+    const arr = this.listeners.get(event)
+    const idx = arr.indexOf(fn)
+    if (idx >= 0) arr.splice(idx, 1)
+    return this
+  }
+
+  once(event, fn) {
+    const wrapper = (...args) => {
+      fn(...args)
+      this.off(event, wrapper)
+    }
+    this.on(event, wrapper)
+    return this
+  }
+
+  emit(event, ...args) {
+    if (!this.listeners.has(event)) return false
+    this.listeners.get(event).forEach(fn => {
+      try {
+        fn(...args)
+      } catch (err) {
+        console.error(`Error in listener for event '${event}':`, err)
+      }
+    })
+    return true
+  }
+
+  removeListener(event, fn) {
+    return this.off(event, fn)
+  }
+
+  removeAllListeners(event) {
+    if (event) {
+      this.listeners.delete(event)
+    } else {
+      this.listeners.clear()
+    }
+    return this
+  }
+
+  listenerCount(event) {
+    if (!this.listeners.has(event)) return 0
+    return this.listeners.get(event).length
+  }
+}

package/src/protocol/MessageTypes.js

@@ -0,0 +1,73 @@
+export const MSG = {
+  HANDSHAKE: 0x01,
+  HANDSHAKE_ACK: 0x02,
+  HEARTBEAT: 0x03,
+  HEARTBEAT_ACK: 0x04,
+
+  SNAPSHOT: 0x10,
+  INPUT: 0x11,
+  STATE_CORRECTION: 0x12,
+  DELTA_UPDATE: 0x13,
+
+  PLAYER_JOIN: 0x20,
+  PLAYER_LEAVE: 0x21,
+  PLAYER_INPUT: 0x22,
+
+  ENTITY_SPAWN: 0x30,
+  ENTITY_DESTROY: 0x31,
+  ENTITY_UPDATE: 0x32,
+  APP_EVENT: 0x33,
+
+  CLIENT_LOG: 0x40,
+  CLIENT_ERROR: 0x41,
+  CLIENT_WARN: 0x42,
+  CLIENT_PERF: 0x43,
+  CLIENT_STATE: 0x44,
+
+  SERVER_LOG: 0x50,
+  DEBUG_SNAPSHOT: 0x51,
+  INSPECT_ENTITY: 0x52,
+  INSPECT_RESPONSE: 0x53,
+
+  RECONNECT: 0x60,
+  RECONNECT_ACK: 0x61,
+  STATE_RECOVERY: 0x62,
+  DISCONNECT_REASON: 0x63,
+
+  HOT_RELOAD: 0x70,
+  WORLD_DEF: 0x71,
+  APP_MODULE: 0x72,
+  ASSET_UPDATE: 0x73,
+  BUS_EVENT: 0x74
+}
+
+const nameMap = new Map()
+for (const [name, id] of Object.entries(MSG)) nameMap.set(id, name)
+
+export function msgName(id) {
+  return nameMap.get(id) || `UNKNOWN(0x${id.toString(16)})`
+}
+
+export const UNRELIABLE_MSGS = new Set([
+  0x03, 0x04, 0x10, 0x11, 0x12, 0x13, 0x22, 0x43, 0x44
+])
+
+export function isUnreliable(type) {
+  return UNRELIABLE_MSGS.has(type)
+}
+
+export const DISCONNECT_REASONS = {
+  NORMAL: 0,
+  TIMEOUT: 1,
+  KICKED: 2,
+  SERVER_SHUTDOWN: 3,
+  INVALID_SESSION: 4,
+  RATE_LIMITED: 5
+}
+
+export const CONNECTION_QUALITY = {
+  EXCELLENT: 'excellent',
+  GOOD: 'good',
+  POOR: 'poor',
+  CRITICAL: 'critical'
+}

package/src/protocol/SequenceTracker.js

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

package/src/protocol/msgpack.js

@@ -0,0 +1,119 @@
+const encoder = new TextEncoder()
+const decoder = new TextDecoder()
+
+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)
+        }
+      } 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]) }
+    }
+  }
+  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])
+  }
+  write(value)
+  return new Uint8Array(chunks)
+}
+
+export function unpack(buffer) {
+  const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer)
+  let offset = 0
+  function read() {
+    const byte = bytes[offset++]
+    if (byte < 0x80) return byte
+    if ((byte & 0xf0) === 0x80) return readMap(byte & 0x0f)
+    if ((byte & 0xf0) === 0x90) return readArray(byte & 0x0f)
+    if ((byte & 0xe0) === 0xa0) return readString(byte & 0x1f)
+    if (byte >= 0xe0) return byte - 256
+    switch (byte) {
+      case 0xc0: return null
+      case 0xc2: return false
+      case 0xc3: return true
+      case 0xc4: return readBin(bytes[offset++])
+      case 0xc5: return readBin(readUint16())
+      case 0xc6: return readBin(readUint32())
+      case 0xca: return readFloat32()
+      case 0xcb: return readFloat64()
+      case 0xcc: return bytes[offset++]
+      case 0xcd: return readUint16()
+      case 0xce: return readUint32()
+      case 0xd0: return readInt8()
+      case 0xd1: return readInt16()
+      case 0xd2: return readInt32()
+      case 0xd9: return readString(bytes[offset++])
+      case 0xda: return readString(readUint16())
+      case 0xdb: return readString(readUint32())
+      case 0xdc: return readArray(readUint16())
+      case 0xdd: return readArray(readUint32())
+      case 0xde: return readMap(readUint16())
+      case 0xdf: return readMap(readUint32())
+      default: throw new Error(`Unknown msgpack type: 0x${byte.toString(16)}`)
+    }
+  }
+  function readUint16() { const v = (bytes[offset] << 8) | bytes[offset + 1]; offset += 2; return v }
+  function readUint32() { const v = (bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3]; offset += 4; return v >>> 0 }
+  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 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 }
+  function readMap(len) { const obj = {}; for (let i = 0; i < len; i++) { const key = read(); obj[key] = read() } return obj }
+  return read()
+}