murow 0.0.73 → 0.1.1

package/dist/netcode/cjs/index.js

@@ -0,0 +1,1552 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AoiGrid: () => AoiGrid,
+  GameClient: () => GameClient,
+  GameServer: () => GameServer,
+  LagCompensation: () => LagCompensation,
+  MemoryPeerTransport: () => MemoryPeerTransport,
+  MemoryServerTransport: () => MemoryServerTransport,
+  Network: () => Network,
+  decodeDelta: () => decodeDelta,
+  defineHandlers: () => defineHandlers,
+  defineIntents: () => defineIntents,
+  definePredictions: () => definePredictions,
+  defineRpcs: () => defineRpcs,
+  encodeDelta: () => encodeDelta,
+  makeFieldsAccessor: () => makeFieldsAccessor,
+  makeMarkDirty: () => makeMarkDirty,
+  networked: () => networked
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/intents/define-intents.ts
+var import_protocol = require("murow/protocol");
+function defineIntents(intents) {
+  const defs = {};
+  const kindByName = {};
+  const nameByKind = {};
+  const registry = new import_protocol.IntentRegistry();
+  let nextKind = 1;
+  for (const name of Object.keys(intents)) {
+    const kind = nextKind++;
+    const def = (0, import_protocol.defineIntent)({
+      kind,
+      schema: intents[name]
+    });
+    defs[name] = def;
+    kindByName[name] = kind;
+    nameByKind[kind] = name;
+    registry.register(def);
+  }
+  return {
+    defs,
+    kindByName,
+    nameByKind,
+    registry,
+    __payloads: void 0
+  };
+}
+
+// src/rpcs/define-rpcs.ts
+var import_protocol2 = require("murow/protocol");
+function defineRpcs(rpcs) {
+  const defs = {};
+  const registry = new import_protocol2.RpcRegistry();
+  for (const method of Object.keys(rpcs)) {
+    const def = (0, import_protocol2.defineRPC)({ method, schema: rpcs[method] });
+    defs[method] = def;
+    registry.register(def);
+  }
+  return {
+    defs,
+    registry,
+    __payloads: void 0
+  };
+}
+
+// src/predictions/define-predictions.ts
+function definePredictions(intents, map) {
+  return { __kind: "predictions", intents, map };
+}
+
+// src/handlers/define-handlers.ts
+function defineHandlers(intents, map) {
+  return { __kind: "handlers", intents, map };
+}
+
+// src/network/base.ts
+var import_events = require("murow/core/events");
+var Network = class extends import_events.EventSystem {
+  constructor(events) {
+    super({ events });
+  }
+};
+
+// src/server/game-server.ts
+var import_simple_rng = require("murow/core/simple-rng");
+var import_binary_codec = require("murow/core/binary-codec");
+var import_protocol3 = require("murow/protocol");
+
+// src/codec/delta-codec.ts
+var HEADER_BYTES = 4 + 4 + 2 + 2;
+function encodeDelta(world, tick, entities, components, numMaskWords, despawned = [], clientAckTick = 0) {
+  const perEntityMasks = new Array(entities.length);
+  const perEntityBitmaskBytes = numMaskWords * 4;
+  let bodyBytes = 0;
+  for (let i = 0; i < entities.length; i++) {
+    const eid = entities[i];
+    const mask = new Uint32Array(numMaskWords);
+    let componentBytes = 0;
+    for (let ci = 0; ci < components.length; ci++) {
+      const c = components[ci];
+      if (!world.has(eid, c))
+        continue;
+      const wordIndex = ci >>> 5;
+      const bitIndex = ci & 31;
+      mask[wordIndex] |= 1 << bitIndex;
+      componentBytes += c.size;
+    }
+    perEntityMasks[i] = mask;
+    bodyBytes += 4 + perEntityBitmaskBytes + componentBytes;
+  }
+  const despawnBytes = despawned.length * 4;
+  const buf = new Uint8Array(HEADER_BYTES + bodyBytes + despawnBytes);
+  const dv = new DataView(buf.buffer);
+  let off = 0;
+  dv.setUint32(off, tick >>> 0, true);
+  off += 4;
+  dv.setUint32(off, clientAckTick >>> 0, true);
+  off += 4;
+  dv.setUint16(off, entities.length, true);
+  off += 2;
+  dv.setUint16(off, despawned.length, true);
+  off += 2;
+  const componentFieldArrays = new Array(components.length);
+  const componentSchemas = new Array(components.length);
+  const componentAllScalar = new Array(components.length);
+  const maxEntities = world.getMaxEntities();
+  for (let ci = 0; ci < components.length; ci++) {
+    const c = components[ci];
+    const fieldArrays = world.fields(c);
+    componentFieldArrays[ci] = fieldArrays;
+    componentSchemas[ci] = c.schema;
+    let allScalar = true;
+    for (let fi = 0; fi < c.fieldNames.length; fi++) {
+      const fname = c.fieldNames[fi];
+      if (fieldArrays[fname].length !== maxEntities) {
+        allScalar = false;
+        break;
+      }
+    }
+    componentAllScalar[ci] = allScalar;
+  }
+  for (let i = 0; i < entities.length; i++) {
+    const eid = entities[i];
+    const mask = perEntityMasks[i];
+    dv.setUint32(off, eid >>> 0, true);
+    off += 4;
+    for (let w = 0; w < numMaskWords; w++) {
+      dv.setUint32(off, mask[w], true);
+      off += 4;
+    }
+    for (let ci = 0; ci < components.length; ci++) {
+      const wordIndex = ci >>> 5;
+      const bitIndex = ci & 31;
+      if ((mask[wordIndex] & 1 << bitIndex) === 0)
+        continue;
+      const c = components[ci];
+      const fieldArrays = componentFieldArrays[ci];
+      const schema = componentSchemas[ci];
+      const fieldNames = c.fieldNames;
+      if (componentAllScalar[ci]) {
+        for (let fi = 0; fi < fieldNames.length; fi++) {
+          const fieldName = fieldNames[fi];
+          const field = schema[fieldName];
+          field.write(dv, off, fieldArrays[fieldName][eid]);
+          off += field.size;
+        }
+      } else {
+        const data = world.get(eid, c);
+        for (let fi = 0; fi < fieldNames.length; fi++) {
+          const fieldName = fieldNames[fi];
+          const field = schema[fieldName];
+          field.write(dv, off, data[fieldName]);
+          off += field.size;
+        }
+      }
+    }
+  }
+  for (let i = 0; i < despawned.length; i++) {
+    dv.setUint32(off, despawned[i] >>> 0, true);
+    off += 4;
+  }
+  return buf;
+}
+function decodeDelta(world, buf, components, numMaskWords, ensureEntity, shouldApply = () => true) {
+  const dv = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
+  let off = 0;
+  const tick = dv.getUint32(off, true);
+  off += 4;
+  const clientAckTick = dv.getUint32(off, true);
+  off += 4;
+  const entityCount = dv.getUint16(off, true);
+  off += 2;
+  const despawnCount = dv.getUint16(off, true);
+  off += 2;
+  const localEntityIds = [];
+  const serverEntityIds = [];
+  const valuesByServerEntity = /* @__PURE__ */ new Map();
+  for (let i = 0; i < entityCount; i++) {
+    const serverEid = dv.getUint32(off, true);
+    off += 4;
+    serverEntityIds.push(serverEid);
+    const mask = new Uint32Array(numMaskWords);
+    for (let w = 0; w < numMaskWords; w++) {
+      mask[w] = dv.getUint32(off, true);
+      off += 4;
+    }
+    const present = [];
+    for (let ci = 0; ci < components.length; ci++) {
+      const wordIndex = ci >>> 5;
+      const bitIndex = ci & 31;
+      if ((mask[wordIndex] & 1 << bitIndex) !== 0) {
+        present.push(components[ci]);
+      }
+    }
+    const localEid = ensureEntity(serverEid, present);
+    localEntityIds.push(localEid);
+    const applyToWorld = shouldApply(localEid);
+    const compMap = /* @__PURE__ */ new Map();
+    for (const c of present) {
+      const update = {};
+      for (const fieldName of c.fieldNames) {
+        const field = c.schema[fieldName];
+        update[fieldName] = field.read(dv, off);
+        off += field.size;
+      }
+      compMap.set(c, update);
+      if (applyToWorld) {
+        if (!world.has(localEid, c)) {
+          world.add(localEid, c, update);
+        } else {
+          world.update(localEid, c, update);
+        }
+      } else if (!world.has(localEid, c)) {
+        world.add(localEid, c, update);
+      }
+    }
+    valuesByServerEntity.set(serverEid, compMap);
+  }
+  const despawnedServerIds = [];
+  for (let i = 0; i < despawnCount; i++) {
+    despawnedServerIds.push(dv.getUint32(off, true));
+    off += 4;
+  }
+  return {
+    tick,
+    clientAckTick,
+    entityIds: localEntityIds,
+    serverEntityIds,
+    despawnedServerIds,
+    valuesByServerEntity
+  };
+}
+
+// src/ctx.ts
+function makeFieldsAccessor(world, entity) {
+  return function fields(component) {
+    if (component.__sync !== void 0 && component.__worldIndex !== void 0) {
+      world.markDirty(entity, component.__worldIndex);
+    }
+    return world.fields(component);
+  };
+}
+function makeMarkDirty(world, ctxEntity) {
+  function markDirty(arg, entity) {
+    const target = entity ?? ctxEntity;
+    if (Array.isArray(arg)) {
+      for (let i = 0; i < arg.length; i++) {
+        const c = arg[i];
+        if (c.__sync === void 0 || c.__worldIndex === void 0)
+          continue;
+        world.markDirty(target, c.__worldIndex);
+      }
+    } else {
+      const c = arg;
+      if (c.__sync === void 0 || c.__worldIndex === void 0)
+        return;
+      world.markDirty(target, c.__worldIndex);
+    }
+  }
+  return markDirty;
+}
+
+// src/server/game-server.ts
+var PING_RPC = (0, import_protocol3.defineRPC)({ method: "__murow_ping", schema: { ts: import_binary_codec.u16 } });
+var PONG_RPC = (0, import_protocol3.defineRPC)({ method: "__murow_pong", schema: { ts: import_binary_codec.u16 } });
+var MSG_SNAPSHOT = 128;
+var MSG_RPC = 129;
+var MSG_KICK = 130;
+var MSG_ASSIGN_ENTITY = 132;
+var CMSG_INTENT = 1;
+var CMSG_RPC = 2;
+var CMSG_KICK_ACK = 3;
+var GameServer = class extends Network {
+  constructor(opts) {
+    super([
+      "connection",
+      "disconnection",
+      "intent",
+      "intent-failed",
+      "rpc",
+      "snapshot",
+      "error"
+    ]);
+    this.peers = /* @__PURE__ */ new Map();
+    this.predictionMap = null;
+    this.handlerMap = null;
+    this.plugins = [];
+    this.lagComp = null;
+    this.syncedComponents = [];
+    this.syncedNumMaskWords = 1;
+    this.tickCounter = 0;
+    this.scratch = [];
+    this.world = opts.world;
+    this.loop = opts.loop;
+    this.transport = opts.transport;
+    this.intents = opts.protocol.intents;
+    this.rpcs = opts.protocol.rpcs;
+    this.rng = new import_simple_rng.SimpleRNG(1);
+    const reg = this.rpcs.registry;
+    if (!reg.has(PING_RPC.method))
+      reg.register(PING_RPC);
+    if (!reg.has(PONG_RPC.method))
+      reg.register(PONG_RPC);
+    const tickRate = opts.loop.ticker.rate;
+    const requestedSnapshotRate = opts.snapshot?.rate ?? Math.min(20, tickRate);
+    const effectiveSnapshotRate = Math.min(requestedSnapshotRate, tickRate);
+    this.snapshotEvery = Math.max(1, Math.round(tickRate / effectiveSnapshotRate));
+    this.kickAckTimeout = opts.kick?.ackTimeout ?? 2e3;
+    this.lastDt = opts.loop.ticker.intervalMs / 1e3;
+    this.discoverSyncedComponents();
+    this.wireTransport();
+    this.wireLoop();
+  }
+  discoverSyncedComponents() {
+    const all = this.world.components;
+    for (const c of all) {
+      if (c.__sync !== void 0)
+        this.syncedComponents.push(c);
+    }
+    this.syncedNumMaskWords = Math.max(1, Math.ceil(this.syncedComponents.length / 32));
+  }
+  wireTransport() {
+    this.transport.onConnection((peerTransport, peerId) => {
+      const peer = {
+        peerId,
+        entity: -1,
+        transport: peerTransport,
+        kicking: null,
+        lastAckedClientTick: 0,
+        pendingBySequence: /* @__PURE__ */ new Map(),
+        needsBaseline: true,
+        intentQueue: []
+      };
+      this.peers.set(peerId, peer);
+      peerTransport.onMessage((data) => this.handleIncoming(peer, data));
+      peerTransport.onClose?.(() => this.handleDisconnect(peer, "transport-closed"));
+      this.emit("connection", { peer });
+    });
+    this.transport.onDisconnection((peerId) => {
+      const peer = this.peers.get(peerId);
+      if (peer === void 0)
+        return;
+      this.handleDisconnect(peer, "transport-closed");
+    });
+  }
+  handleDisconnect(peer, reason) {
+    if (!this.peers.has(peer.peerId))
+      return;
+    if (peer.kicking !== null)
+      clearTimeout(peer.kicking.timer);
+    this.peers.delete(peer.peerId);
+    for (const plugin of this.plugins)
+      plugin.onDisconnect?.(peer);
+    this.emit("disconnection", { peer, reason });
+  }
+  wireLoop() {
+    const events = this.loop.events;
+    events.on("pre-tick", () => {
+      this.drainIntentQueues();
+    });
+    events.on("post-tick", ({ deltaTime }) => {
+      this.tickCounter++;
+      this.lastDt = deltaTime;
+      for (const plugin of this.plugins)
+        plugin.onTick?.(this.world, deltaTime);
+      if (this.tickCounter % this.snapshotEvery !== 0)
+        return;
+      this.sendSnapshots();
+    });
+  }
+  drainIntentQueues() {
+    this.peers.forEach((peer) => {
+      if (peer.kicking !== null) {
+        peer.intentQueue.length = 0;
+        peer.pendingBySequence.clear();
+        return;
+      }
+      for (let i = 0; i < peer.intentQueue.length; i++) {
+        const entry = peer.intentQueue[i];
+        if (entry.sequence <= peer.lastAckedClientTick)
+          continue;
+        if (peer.pendingBySequence.has(entry.sequence))
+          continue;
+        peer.pendingBySequence.set(entry.sequence, entry.payload);
+      }
+      peer.intentQueue.length = 0;
+      while (peer.pendingBySequence.has(peer.lastAckedClientTick + 1)) {
+        const nextSequence = peer.lastAckedClientTick + 1;
+        const payload = peer.pendingBySequence.get(nextSequence);
+        peer.pendingBySequence.delete(nextSequence);
+        this.handleIntent(peer, nextSequence, payload);
+      }
+      if (peer.pendingBySequence.size > 0) {
+        const STALL_LIMIT = 16;
+        let lowestPending = Infinity;
+        for (const sequence of peer.pendingBySequence.keys()) {
+          if (sequence < lowestPending)
+            lowestPending = sequence;
+        }
+        if (lowestPending - peer.lastAckedClientTick > STALL_LIMIT) {
+          peer.lastAckedClientTick = lowestPending - 1;
+          while (peer.pendingBySequence.has(peer.lastAckedClientTick + 1)) {
+            const nextSequence = peer.lastAckedClientTick + 1;
+            const payload = peer.pendingBySequence.get(nextSequence);
+            peer.pendingBySequence.delete(nextSequence);
+            this.handleIntent(peer, nextSequence, payload);
+          }
+        }
+      }
+    });
+  }
+  sendSnapshots() {
+    if (this.syncedComponents.length === 0)
+      return;
+    const seen = /* @__PURE__ */ new Set();
+    this.scratch.length = 0;
+    for (const c of this.syncedComponents) {
+      this.world.forEachDirty(c, (eid) => {
+        if (!seen.has(eid)) {
+          seen.add(eid);
+          this.scratch.push(eid);
+        }
+      });
+    }
+    const despawnedView = this.world.getDespawned();
+    const despawned = despawnedView.length > 0 ? Array.from(despawnedView) : [];
+    if (despawned.length > 0)
+      this.world.flushDespawned();
+    if (this.scratch.length === 0 && despawned.length === 0 && !this.anyNeedsBaseline()) {
+      return;
+    }
+    let baseline = null;
+    const computeBaseline = () => {
+      if (baseline !== null)
+        return baseline;
+      const result = [];
+      const baselineSeen = /* @__PURE__ */ new Set();
+      for (const c of this.syncedComponents) {
+        for (const eid of this.world.query(c)) {
+          if (!baselineSeen.has(eid)) {
+            baselineSeen.add(eid);
+            result.push(eid);
+          }
+        }
+      }
+      baseline = result;
+      return result;
+    };
+    const peerOut = [];
+    for (const peer of this.peers.values()) {
+      if (peer.kicking !== null)
+        continue;
+      const source = peer.needsBaseline ? computeBaseline() : this.scratch;
+      let current = source;
+      for (const plugin of this.plugins) {
+        if (plugin.filterSnapshot === void 0)
+          continue;
+        peerOut.length = 0;
+        plugin.filterSnapshot(peer, this.world, current, peerOut);
+        current = peerOut.slice();
+      }
+      if (current.length === 0 && despawned.length === 0 && !peer.needsBaseline)
+        continue;
+      const buf = encodeDelta(
+        this.world,
+        this.tickCounter,
+        current,
+        this.syncedComponents,
+        this.syncedNumMaskWords,
+        despawned,
+        peer.lastAckedClientTick
+      );
+      const framed = new Uint8Array(buf.length + 1);
+      framed[0] = MSG_SNAPSHOT;
+      framed.set(buf, 1);
+      peer.transport.send(framed);
+      peer.needsBaseline = false;
+      this.emit("snapshot", { peer, tick: this.tickCounter, byteSize: framed.length });
+    }
+    this.world.clearAllDirty();
+  }
+  anyNeedsBaseline() {
+    for (const peer of this.peers.values()) {
+      if (peer.kicking === null && peer.needsBaseline)
+        return true;
+    }
+    return false;
+  }
+  handleIncoming(peer, data) {
+    if (data.length === 0)
+      return;
+    const type = data[0];
+    if (peer.kicking !== null) {
+      if (type === CMSG_KICK_ACK)
+        this.completeKick(peer);
+      return;
+    }
+    if (type === CMSG_INTENT) {
+      if (data.length < 5) {
+        this.emit("intent-failed", { peer, kind: -1, reason: "decode-error" });
+        return;
+      }
+      const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      const sequence = dv.getUint32(1, true);
+      peer.intentQueue.push({ sequence, payload: data.subarray(5) });
+      return;
+    }
+    if (type === CMSG_RPC) {
+      this.handleRpc(peer, data.subarray(1));
+      return;
+    }
+    this.emit("error", {
+      error: new Error(`Unknown client message type 0x${type.toString(16)}`),
+      context: "handleIncoming"
+    });
+  }
+  handleIntent(peer, sequence, payload) {
+    let intent;
+    try {
+      intent = this.intents.registry.decode(payload);
+    } catch (err) {
+      this.emit("intent-failed", {
+        peer,
+        kind: payload[0] ?? -1,
+        reason: "decode-error"
+      });
+      return;
+    }
+    const name = this.intents.nameByKind[intent.kind];
+    if (name === void 0) {
+      this.emit("intent-failed", {
+        peer,
+        kind: intent.kind,
+        reason: "unknown-kind"
+      });
+      return;
+    }
+    const ctx = {
+      world: this.world,
+      entity: peer.entity,
+      tick: this.tickCounter,
+      deltaTime: this.lastDt,
+      rng: this.rng,
+      fields: makeFieldsAccessor(this.world, peer.entity),
+      markDirty: makeMarkDirty(this.world, peer.entity),
+      peer,
+      clientTick: intent.tick,
+      lagCompensated: (fn) => {
+        if (this.lagComp === null)
+          return fn();
+        return this.lagComp.rewind(intent.tick, fn);
+      }
+    };
+    for (const plugin of this.plugins) {
+      plugin.onIntent?.(peer, intent.kind, name, intent, ctx);
+    }
+    const predFn = this.predictionMap?.[name];
+    if (predFn)
+      predFn(intent, ctx);
+    const handlerFn = this.handlerMap?.[name];
+    if (handlerFn)
+      handlerFn(intent, ctx);
+    peer.lastAckedClientTick = sequence;
+    this.emit("intent", {
+      peer,
+      kind: intent.kind,
+      name,
+      payload: intent,
+      tick: intent.tick
+    });
+  }
+  handleRpc(peer, payload) {
+    try {
+      const decoded = this.rpcs.registry.decode(payload);
+      if (decoded.method === "__murow_ping") {
+        const encoded = this.rpcs.registry.encode(PONG_RPC, { ts: decoded.data.ts });
+        const framed = new Uint8Array(encoded.length + 1);
+        framed[0] = MSG_RPC;
+        framed.set(encoded, 1);
+        peer.transport.send(framed);
+        return;
+      }
+      this.emit("rpc", { peer, name: decoded.method, payload: decoded.data });
+    } catch (err) {
+      this.emit("error", { error: err, context: "handleRpc" });
+    }
+  }
+  use(bundle) {
+    if (bundle && bundle.__kind === "predictions") {
+      this.predictionMap = bundle.map;
+      return this;
+    }
+    if (bundle && bundle.__kind === "handlers") {
+      this.handlerMap = bundle.map;
+      return this;
+    }
+    const plugin = bundle;
+    this.plugins.push(plugin);
+    plugin.onMount?.(this);
+    if (plugin.name === "lag-compensation" || plugin.rewind !== void 0) {
+      this.lagComp = plugin;
+    }
+    return this;
+  }
+  /**
+   * Bind an entity to a peer. Fills `ctx.entity` for the peer's intents
+   * and pushes a MSG_ASSIGN_ENTITY frame so the client knows which
+   * entity it owns.
+   */
+  assignEntity(peer, entityId) {
+    const internal = this.peers.get(peer.peerId);
+    if (internal === void 0)
+      return;
+    internal.entity = entityId;
+    const frame = new Uint8Array(1 + 4);
+    frame[0] = MSG_ASSIGN_ENTITY;
+    new DataView(frame.buffer).setUint32(1, entityId >>> 0, true);
+    internal.transport.send(frame);
+  }
+  sendRpc(peer, name, payload) {
+    const internal = this.peers.get(peer.peerId);
+    if (internal === void 0)
+      return;
+    if (internal.kicking !== null)
+      return;
+    const def = this.rpcs.defs[name];
+    if (def === void 0) {
+      this.emit("error", {
+        error: new Error(`Unknown RPC "${String(name)}"`),
+        context: "sendRpc"
+      });
+      return;
+    }
+    const encoded = this.rpcs.registry.encode(def, payload);
+    const framed = new Uint8Array(encoded.length + 1);
+    framed[0] = MSG_RPC;
+    framed.set(encoded, 1);
+    internal.transport.send(framed);
+  }
+  broadcastRpc(name, payload) {
+    for (const peer of this.peers.values()) {
+      if (peer.kicking !== null)
+        continue;
+      this.sendRpc(peer, name, payload);
+    }
+  }
+  /**
+   * Soft-kick: send KICK frame, wait `kick.ackTimeout` for the client's
+   * ack, then force the transport closed.
+   */
+  kick(peer, reason) {
+    const internal = this.peers.get(peer.peerId);
+    if (internal === void 0)
+      return;
+    if (internal.kicking !== null)
+      return;
+    const reasonBytes = new TextEncoder().encode(reason);
+    const framed = new Uint8Array(reasonBytes.length + 1);
+    framed[0] = MSG_KICK;
+    framed.set(reasonBytes, 1);
+    internal.transport.send(framed);
+    const timer = setTimeout(() => this.completeKick(internal), this.kickAckTimeout);
+    internal.kicking = { reason, sentAt: Date.now(), timer };
+  }
+  completeKick(peer) {
+    if (peer.kicking === null)
+      return;
+    clearTimeout(peer.kicking.timer);
+    this.handleDisconnect(peer, "kicked");
+    peer.transport.close();
+  }
+};
+
+// src/server/plugins/aoi-grid.ts
+var AoiGrid = class {
+  constructor(opts) {
+    this.name = opts.name ?? "aoi";
+    this.cellSize = opts.cellSize;
+    this.radius = opts.radius;
+    this.hysteresisRadius = opts.hysteresisRadius ?? 0;
+    this.positionComponent = opts.positionComponent;
+  }
+  filterSnapshot(peer, world, dirtyEntities, out) {
+    if (peer.entity === -1 || !world.has(peer.entity, this.positionComponent)) {
+      for (let i = 0; i < dirtyEntities.length; i++)
+        out.push(dirtyEntities[i]);
+      return;
+    }
+    const fields = world.fields(this.positionComponent);
+    const xs = fields.x;
+    const ys = fields.y;
+    const px = xs[peer.entity];
+    const py = ys[peer.entity];
+    const maxR = this.radius + this.hysteresisRadius;
+    const maxR2 = maxR * maxR;
+    for (let i = 0; i < dirtyEntities.length; i++) {
+      const eid = dirtyEntities[i];
+      if (!world.has(eid, this.positionComponent)) {
+        out.push(eid);
+        continue;
+      }
+      const dx = xs[eid] - px;
+      const dy = ys[eid] - py;
+      if (dx * dx + dy * dy <= maxR2)
+        out.push(eid);
+    }
+  }
+};
+
+// src/server/plugins/lag-compensation.ts
+var LagCompensation = class {
+  constructor(opts) {
+    this.componentIndices = [];
+    this.ringBuffer = [];
+    this.ringHead = 0;
+    this.currentTick = 0;
+    this.world = null;
+    this.name = opts.name ?? "lag-compensation";
+    this.historyMs = opts.historyMs ?? 500;
+    this.tickRate = opts.tickRate;
+    this.components = opts.components;
+    this.ringSize = Math.ceil(this.historyMs / 1e3 * this.tickRate) + 1;
+    for (let i = 0; i < this.ringSize; i++) {
+      this.ringBuffer.push({ tick: -1, snapshots: [] });
+    }
+  }
+  onMount(server) {
+    this.world = server.world;
+    for (const c of this.components) {
+      if (c.__worldIndex === void 0) {
+        throw new Error(
+          `LagCompensation: component "${c.name}" is not registered in the world.`
+        );
+      }
+      this.componentIndices.push(c.__worldIndex);
+    }
+  }
+  onTick(_world, _dt) {
+    const world = this.world;
+    if (world === null)
+      return;
+    this.currentTick++;
+    const frame = this.ringBuffer[this.ringHead];
+    frame.tick = this.currentTick;
+    frame.snapshots = [];
+    for (let i = 0; i < this.components.length; i++) {
+      const c = this.components[i];
+      const snap = /* @__PURE__ */ new Map();
+      world.forEachDirty(c, (eid) => {
+        snap.set(eid, { ...world.get(eid, c) });
+      });
+      if (snap.size === 0) {
+        for (const eid of world.query(c)) {
+          snap.set(eid, { ...world.get(eid, c) });
+        }
+      }
+      frame.snapshots[i] = snap;
+    }
+    this.ringHead = (this.ringHead + 1) % this.ringSize;
+  }
+  rewind(clientTick, fn) {
+    const world = this.world;
+    if (world === null)
+      return fn();
+    let chosen = null;
+    let bestDelta = Number.MAX_SAFE_INTEGER;
+    for (const frame of this.ringBuffer) {
+      if (frame.tick < 0)
+        continue;
+      const d = Math.abs(frame.tick - clientTick);
+      if (d < bestDelta) {
+        bestDelta = d;
+        chosen = frame;
+      }
+    }
+    if (chosen === null)
+      return fn();
+    const saved = [];
+    for (let i = 0; i < this.components.length; i++) {
+      const c = this.components[i];
+      const snap = chosen.snapshots[i];
+      if (!snap) {
+        saved[i] = /* @__PURE__ */ new Map();
+        continue;
+      }
+      const savedFrame = /* @__PURE__ */ new Map();
+      for (const [eid, value] of snap) {
+        if (world.has(eid, c)) {
+          savedFrame.set(eid, { ...world.get(eid, c) });
+          world.set(eid, c, value);
+        }
+      }
+      saved[i] = savedFrame;
+    }
+    try {
+      return fn();
+    } finally {
+      for (let i = 0; i < this.components.length; i++) {
+        const c = this.components[i];
+        const savedFrame = saved[i];
+        for (const [eid, value] of savedFrame) {
+          if (world.has(eid, c))
+            world.set(eid, c, value);
+        }
+      }
+    }
+  }
+};
+
+// src/client/game-client.ts
+var import_binary_codec2 = require("murow/core/binary-codec");
+var import_simple_rng2 = require("murow/core/simple-rng");
+var import_protocol4 = require("murow/protocol");
+
+// src/client/interpolation-buffer.ts
+var import_lerp = require("murow/core/lerp");
+function modeFor(c) {
+  const sync = c.__sync;
+  return sync?.interp ?? "lerp";
+}
+var InterpolationBuffer = class {
+  constructor(serverToLocal, capacity, delayMs, staleWindowMs) {
+    this.buffer = [];
+    this.renderTick = -Infinity;
+    this.latestReceivedAt = -Infinity;
+    this.smoothedTickRateMs = 0;
+    this.serverToLocal = serverToLocal;
+    this.capacity = capacity;
+    this.delay = delayMs;
+    this.staleWindow = staleWindowMs;
+  }
+  setDelay(delayMs) {
+    this.delay = delayMs;
+  }
+  setStaleWindow(staleWindowMs) {
+    this.staleWindow = staleWindowMs;
+  }
+  record(snapshot) {
+    const gap = snapshot.receivedAt - this.latestReceivedAt;
+    if (this.buffer.length > 0 && gap > this.staleWindow) {
+      this.buffer.length = 0;
+      this.renderTick = -Infinity;
+      this.latestReceivedAt = -Infinity;
+      this.smoothedTickRateMs = 0;
+    }
+    if (snapshot.receivedAt > this.latestReceivedAt) {
+      this.latestReceivedAt = snapshot.receivedAt;
+    }
+    let insertAt = this.buffer.length;
+    while (insertAt > 0 && this.buffer[insertAt - 1].serverTick >= snapshot.serverTick) {
+      if (this.buffer[insertAt - 1].serverTick === snapshot.serverTick)
+        return;
+      insertAt--;
+    }
+    this.buffer.splice(insertAt, 0, snapshot);
+    while (this.buffer.length > this.capacity)
+      this.buffer.shift();
+  }
+  clear() {
+    this.buffer.length = 0;
+    this.renderTick = -Infinity;
+    this.latestReceivedAt = -Infinity;
+    this.smoothedTickRateMs = 0;
+  }
+  apply(world, now, components, shouldSkip) {
+    if (this.buffer.length === 0)
+      return;
+    const newest = this.buffer[this.buffer.length - 1];
+    const oldest = this.buffer[0];
+    let tickRateMs = 0;
+    if (this.buffer.length >= 2) {
+      const tickSpan = newest.serverTick - oldest.serverTick;
+      const wallSpan = this.latestReceivedAt - oldest.receivedAt;
+      const rawTickRateMs = tickSpan > 0 && wallSpan > 0 ? wallSpan / tickSpan : 0;
+      if (rawTickRateMs > 0) {
+        if (this.smoothedTickRateMs === 0)
+          this.smoothedTickRateMs = rawTickRateMs;
+        else
+          this.smoothedTickRateMs = this.smoothedTickRateMs * 0.9 + rawTickRateMs * 0.1;
+      }
+      tickRateMs = this.smoothedTickRateMs;
+    }
+    if (tickRateMs === 0) {
+      if (now - newest.receivedAt < this.delay)
+        return;
+      this.writeSnapshot(world, newest, components, shouldSkip);
+      return;
+    }
+    const ageBeyondDelay = now - newest.receivedAt - this.delay;
+    const targetTick = newest.serverTick + ageBeyondDelay / tickRateMs;
+    if (this.renderTick === -Infinity) {
+      this.renderTick = targetTick;
+    } else {
+      const drift = targetTick - this.renderTick;
+      if (drift > 2) {
+        this.renderTick = targetTick;
+      } else {
+        const warp = Math.max(0.9, Math.min(1.1, 1 + drift * 0.05));
+        this.renderTick += warp;
+      }
+    }
+    const renderTick = this.renderTick;
+    let a = null;
+    let b = null;
+    for (let i = 0; i < this.buffer.length - 1; i++) {
+      const s0 = this.buffer[i];
+      const s1 = this.buffer[i + 1];
+      if (s0.serverTick <= renderTick && renderTick <= s1.serverTick) {
+        a = s0;
+        b = s1;
+        break;
+      }
+    }
+    if (a === null || b === null) {
+      if (renderTick < oldest.serverTick)
+        return;
+      this.writeSnapshot(world, newest, components, shouldSkip);
+      return;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const eid of a.entityIds)
+      seen.add(eid);
+    for (const eid of b.entityIds)
+      seen.add(eid);
+    const aIndex = this.buffer.indexOf(a);
+    const bIndex = this.buffer.indexOf(b);
+    for (const serverEid of seen) {
+      const localEid = this.serverToLocal.get(serverEid);
+      if (localEid === void 0)
+        continue;
+      if (shouldSkip(localEid))
+        continue;
+      for (const c of components) {
+        let aIdx = aIndex;
+        let va = a.componentValuesByEntity.get(serverEid)?.get(c);
+        while (va === void 0 && aIdx > 0) {
+          aIdx--;
+          va = this.buffer[aIdx].componentValuesByEntity.get(serverEid)?.get(c);
+        }
+        let bIdx = bIndex;
+        let vb = b.componentValuesByEntity.get(serverEid)?.get(c);
+        while (vb === void 0 && bIdx < this.buffer.length - 1) {
+          bIdx++;
+          vb = this.buffer[bIdx].componentValuesByEntity.get(serverEid)?.get(c);
+        }
+        if (va === void 0 && vb === void 0)
+          continue;
+        let toWrite;
+        if (vb === void 0) {
+          toWrite = va;
+        } else if (va === void 0) {
+          toWrite = vb;
+        } else {
+          const mode = modeFor(c);
+          if (mode === "none") {
+            toWrite = vb;
+          } else {
+            const aTick = this.buffer[aIdx].serverTick;
+            const bTick = this.buffer[bIdx].serverTick;
+            const wideSpan = bTick - aTick;
+            const wideT = wideSpan > 0 ? Math.min(1, Math.max(0, (renderTick - aTick) / wideSpan)) : 0;
+            if (mode === "step") {
+              toWrite = wideT < 0.5 ? va : vb;
+            } else {
+              const out = {};
+              for (const fieldName of c.fieldNames) {
+                out[fieldName] = (0, import_lerp.lerp)(
+                  va[fieldName],
+                  vb[fieldName],
+                  wideT
+                );
+              }
+              toWrite = out;
+            }
+          }
+        }
+        if (toWrite === void 0)
+          continue;
+        if (world.has(localEid, c)) {
+          world.update(localEid, c, toWrite);
+        } else {
+          world.add(localEid, c, toWrite);
+        }
+      }
+    }
+  }
+  writeSnapshot(world, snap, components, shouldSkip) {
+    for (const serverEid of snap.entityIds) {
+      const localEid = this.serverToLocal.get(serverEid);
+      if (localEid === void 0)
+        continue;
+      if (shouldSkip(localEid))
+        continue;
+      const comps = snap.componentValuesByEntity.get(serverEid);
+      if (comps === void 0)
+        continue;
+      for (const c of components) {
+        const v = comps.get(c);
+        if (v === void 0)
+          continue;
+        if (world.has(localEid, c))
+          world.update(localEid, c, v);
+        else
+          world.add(localEid, c, v);
+      }
+    }
+  }
+};
+
+// src/client/game-client.ts
+var MSG_SNAPSHOT2 = 128;
+var MSG_RPC2 = 129;
+var MSG_KICK2 = 130;
+var MSG_ASSIGN_ENTITY2 = 132;
+var CMSG_INTENT2 = 1;
+var CMSG_RPC2 = 2;
+var CMSG_KICK_ACK2 = 3;
+var PING_RPC2 = (0, import_protocol4.defineRPC)({ method: "__murow_ping", schema: { ts: import_binary_codec2.u16 } });
+var PONG_RPC2 = (0, import_protocol4.defineRPC)({ method: "__murow_pong", schema: { ts: import_binary_codec2.u16 } });
+var GameClient = class extends Network {
+  constructor(opts) {
+    super([
+      "connected",
+      "disconnected",
+      "kicked",
+      "snapshot",
+      "rpc",
+      "spawn",
+      "despawn",
+      "reconciled",
+      "assigned",
+      "pong",
+      "error"
+    ]);
+    this.predictionMap = null;
+    this.predictionHistory = [];
+    this.localTick = 0;
+    this.intentSequence = 0;
+    this.lastServerTick = 0;
+    this.lastReconciledServerTick = 0;
+    this.serverToLocal = /* @__PURE__ */ new Map();
+    this.syncedComponents = [];
+    this.syncedNumMaskWords = 1;
+    this.predictedEntities = /* @__PURE__ */ new Set();
+    /** Set when MSG_ASSIGN_ENTITY lands before the matching spawn. */
+    this.pendingAssignedServerEid = null;
+    /** Resolved local entity for the server's assignment. Default for sendIntent. */
+    this._assignedEntity = null;
+    this._rttMs = null;
+    this.world = opts.world;
+    this.loop = opts.loop;
+    this.transport = opts.transport;
+    this.intents = opts.protocol.intents;
+    this.rpcs = opts.protocol.rpcs;
+    const reg = this.rpcs.registry;
+    if (!reg.has(PING_RPC2.method))
+      reg.register(PING_RPC2);
+    if (!reg.has(PONG_RPC2.method))
+      reg.register(PONG_RPC2);
+    const strategy = opts.strategy ?? { kind: "snapshot-interpolation" };
+    const interpolationDelay = strategy.delay ?? 100;
+    const staleWindowMs = strategy.staleWindow ?? interpolationDelay * 2 + 100;
+    this.predictionBufferSize = opts.prediction?.bufferSize ?? 64;
+    this.rng = new import_simple_rng2.SimpleRNG(1);
+    this.lastDt = opts.loop.ticker.intervalMs / 1e3;
+    this.now = opts.now ?? (() => performance.now());
+    this.interpBuffer = new InterpolationBuffer(
+      this.serverToLocal,
+      16,
+      interpolationDelay,
+      staleWindowMs
+    );
+    this.discoverSyncedComponents();
+    this.wireTransport();
+    this.wireLoop();
+  }
+  /**
+   * Local entity the server has assigned to this peer, or `null` if no
+   * assignment has been received yet. `sendIntent` is a no-op (emits an
+   * `'error'` event) until this is set.
+   */
+  get assignedEntity() {
+    return this._assignedEntity;
+  }
+  /**
+   * Last measured round-trip time in milliseconds, or `null` if no pong
+   * has come back yet. Updated whenever a `'pong'` event fires.
+   */
+  get rttMs() {
+    return this._rttMs;
+  }
+  discoverSyncedComponents() {
+    const all = this.world.components;
+    for (const c of all) {
+      if (c.__sync !== void 0)
+        this.syncedComponents.push(c);
+    }
+    this.syncedNumMaskWords = Math.max(1, Math.ceil(this.syncedComponents.length / 32));
+  }
+  wireTransport() {
+    this.transport.onOpen?.(() => this.emit("connected", {}));
+    this.transport.onMessage((data) => this.handleIncoming(data));
+    this.transport.onClose(() => this.emit("disconnected", { reason: "transport-closed" }));
+    this.transport.onError?.((error) => this.emit("error", { error, context: "transport" }));
+  }
+  wireLoop() {
+    const events = this.loop.events;
+    events.on("sync", () => {
+      this.interpBuffer.apply(
+        this.world,
+        this.now(),
+        this.syncedComponents,
+        (e) => this.predictedEntities.has(e)
+      );
+    });
+    events.on("tick", ({ deltaTime }) => {
+      this.localTick++;
+      this.lastDt = deltaTime;
+    });
+  }
+  handleIncoming(data) {
+    if (data.length === 0)
+      return;
+    const type = data[0];
+    if (type === MSG_SNAPSHOT2) {
+      this.handleSnapshot(data.subarray(1));
+      return;
+    }
+    if (type === MSG_RPC2) {
+      this.handleRpc(data.subarray(1));
+      return;
+    }
+    if (type === MSG_KICK2) {
+      const reason = new TextDecoder().decode(data.subarray(1));
+      this.emit("kicked", { reason });
+      const ack = new Uint8Array([CMSG_KICK_ACK2]);
+      this.transport.send(ack);
+      return;
+    }
+    if (type === MSG_ASSIGN_ENTITY2) {
+      if (data.length < 5) {
+        this.emit("error", {
+          error: new Error("MSG_ASSIGN_ENTITY frame too short"),
+          context: "handleIncoming"
+        });
+        return;
+      }
+      const view = new DataView(data.buffer, data.byteOffset + 1, 4);
+      this.applyAssignment(view.getUint32(0, true));
+      return;
+    }
+    this.emit("error", {
+      error: new Error(`Unknown server message type 0x${type.toString(16)}`),
+      context: "handleIncoming"
+    });
+  }
+  handleSnapshot(payload) {
+    try {
+      const decoded = decodeDelta(
+        this.world,
+        payload,
+        this.syncedComponents,
+        this.syncedNumMaskWords,
+        (serverEid, present) => this.ensureEntity(serverEid, present),
+        // Never overwrite live state from the snapshot path.
+        // Predicted entities go through reconcile; peer entities
+        // go through the buffer's `sync` apply. decodeDelta still
+        // archetype-inits first-appearance components.
+        () => false
+      );
+      this.lastServerTick = decoded.tick;
+      this.emit("snapshot", { tick: decoded.tick, byteSize: payload.length + 1 });
+      this.interpBuffer.record({
+        receivedAt: this.now(),
+        serverTick: decoded.tick,
+        entityIds: decoded.serverEntityIds,
+        componentValuesByEntity: decoded.valuesByServerEntity
+      });
+      for (const serverEid of decoded.despawnedServerIds) {
+        const localEid = this.serverToLocal.get(serverEid);
+        if (localEid === void 0)
+          continue;
+        this.serverToLocal.delete(serverEid);
+        if (this.world.isAlive(localEid))
+          this.world.despawn(localEid);
+        this.emit("despawn", { entity: localEid });
+      }
+      if (decoded.tick <= this.lastReconciledServerTick)
+        return;
+      this.lastReconciledServerTick = decoded.tick;
+      this.reconcile(decoded);
+    } catch (err) {
+      this.emit("error", { error: err, context: "handleSnapshot" });
+    }
+  }
+  ensureEntity(serverEid, present) {
+    let localEid = this.serverToLocal.get(serverEid);
+    if (localEid === void 0) {
+      localEid = this.world.spawn();
+      this.serverToLocal.set(serverEid, localEid);
+      const components = {};
+      for (const c of present)
+        components[c.name] = true;
+      this.emit("spawn", { entity: localEid, components });
+      if (this.pendingAssignedServerEid === serverEid) {
+        this.pendingAssignedServerEid = null;
+        this.predictedEntities.add(localEid);
+        this._assignedEntity = localEid;
+        this.emit("assigned", { entity: localEid });
+      }
+    }
+    return localEid;
+  }
+  applyAssignment(serverEid) {
+    const localEid = this.serverToLocal.get(serverEid);
+    if (localEid === void 0) {
+      this.pendingAssignedServerEid = serverEid;
+      return;
+    }
+    this.predictedEntities.add(localEid);
+    this._assignedEntity = localEid;
+    this.emit("assigned", { entity: localEid });
+  }
+  /**
+   * Rewind predicted entities to authoritative state, drop predictions
+   * the server has acked, replay the rest on top.
+   */
+  reconcile(decoded) {
+    const resetEntities = /* @__PURE__ */ new Set();
+    for (const serverEid of decoded.serverEntityIds) {
+      const localEid = this.serverToLocal.get(serverEid);
+      if (localEid === void 0)
+        continue;
+      if (!this.predictedEntities.has(localEid))
+        continue;
+      const comps = decoded.valuesByServerEntity.get(serverEid);
+      if (comps === void 0)
+        continue;
+      for (const [c, value] of comps) {
+        if (this.world.has(localEid, c)) {
+          this.world.update(localEid, c, value);
+        } else {
+          this.world.add(localEid, c, value);
+        }
+      }
+      resetEntities.add(localEid);
+    }
+    const ackSequence = decoded.clientAckTick;
+    let cut = 0;
+    while (cut < this.predictionHistory.length && this.predictionHistory[cut].sequence <= ackSequence) {
+      cut++;
+    }
+    if (cut > 0)
+      this.predictionHistory.splice(0, cut);
+    const remaining = this.predictionHistory.length;
+    if (remaining === 0) {
+      this.emit("reconciled", { rewindTick: ackSequence, replayed: 0 });
+      return;
+    }
+    let replayedCount = 0;
+    for (let i = 0; i < remaining; i++) {
+      const pred = this.predictionHistory[i];
+      if (!resetEntities.has(pred.entity))
+        continue;
+      const predFn = this.predictionMap?.[pred.name];
+      if (predFn === void 0)
+        continue;
+      const ctx = {
+        world: this.world,
+        entity: pred.entity,
+        tick: pred.tick,
+        deltaTime: pred.deltaTime,
+        rng: this.rng,
+        fields: makeFieldsAccessor(this.world, pred.entity),
+        markDirty: makeMarkDirty(this.world, pred.entity)
+      };
+      predFn(pred.payload, ctx);
+      replayedCount++;
+    }
+    this.emit("reconciled", {
+      rewindTick: ackSequence,
+      replayed: replayedCount
+    });
+  }
+  handleRpc(payload) {
+    try {
+      const { method, data } = this.rpcs.registry.decode(payload);
+      if (method === "__murow_pong") {
+        const rtt = Date.now() - data.ts & 65535;
+        this._rttMs = rtt;
+        this.emit("pong", { rtt });
+      }
+      this.emit("rpc", { name: method, payload: data });
+    } catch (err) {
+      this.emit("error", { error: err, context: "handleRpc" });
+    }
+  }
+  use(bundle) {
+    if (bundle && bundle.__kind === "predictions") {
+      this.predictionMap = bundle.map;
+      return this;
+    }
+    return this;
+  }
+  /**
+   * Send an intent to the server. `ctx.entity` in the prediction is the
+   * server-assigned entity. Target entities (chestId, targetId, etc.)
+   * belong in the payload itself.
+   *
+   * Returns `true` when the intent was sent, `false` when blocked. Both
+   * blocked paths emit an `'error'` event so calling code can react:
+   * - Unknown intent name.
+   * - No entity assigned yet (server hasn't called `assignEntity` for
+   *   this peer). Check `client.assignedEntity` if you want to know
+   *   without sending.
+   */
+  sendIntent(name, payload) {
+    const def = this.intents.defs[name];
+    if (def === void 0) {
+      this.emit("error", {
+        error: new Error(`Unknown intent "${String(name)}"`),
+        context: "sendIntent"
+      });
+      return false;
+    }
+    const entity = this._assignedEntity;
+    if (entity === null) {
+      this.emit("error", {
+        error: new Error(`Cannot send intent "${String(name)}": no entity assigned yet`),
+        context: "sendIntent"
+      });
+      return false;
+    }
+    const intentObj = { ...payload, kind: def.kind, tick: this.localTick };
+    const encoded = this.intents.registry.encode(intentObj);
+    const sequence = ++this.intentSequence;
+    const framed = new Uint8Array(encoded.length + 5);
+    framed[0] = CMSG_INTENT2;
+    const dv = new DataView(framed.buffer, framed.byteOffset, framed.byteLength);
+    dv.setUint32(1, sequence >>> 0, true);
+    framed.set(encoded, 5);
+    this.transport.send(framed);
+    const predFn = this.predictionMap?.[name];
+    if (predFn !== void 0) {
+      const deltaTime = this.lastDt;
+      const ctx = {
+        world: this.world,
+        entity,
+        tick: this.localTick,
+        deltaTime,
+        rng: this.rng,
+        fields: makeFieldsAccessor(this.world, entity),
+        markDirty: makeMarkDirty(this.world, entity)
+      };
+      predFn(payload, ctx);
+      this.predictionHistory.push({
+        tick: this.localTick,
+        sequence,
+        name,
+        payload,
+        entity,
+        deltaTime
+      });
+      this.predictedEntities.add(entity);
+      while (this.predictionHistory.length > this.predictionBufferSize) {
+        this.predictionHistory.shift();
+      }
+    }
+    return true;
+  }
+  sendRpc(name, payload) {
+    const def = this.rpcs.defs[name];
+    if (def === void 0) {
+      this.emit("error", {
+        error: new Error(`Unknown RPC "${String(name)}"`),
+        context: "sendRpc"
+      });
+      return;
+    }
+    const encoded = this.rpcs.registry.encode(def, payload);
+    const framed = new Uint8Array(encoded.length + 1);
+    framed[0] = CMSG_RPC2;
+    framed.set(encoded, 1);
+    this.transport.send(framed);
+  }
+  ping() {
+    const ts = Date.now() & 65535;
+    const encoded = this.rpcs.registry.encode(PING_RPC2, { ts });
+    const framed = new Uint8Array(encoded.length + 1);
+    framed[0] = CMSG_RPC2;
+    framed.set(encoded, 1);
+    this.transport.send(framed);
+  }
+  getLocalTick() {
+    return this.localTick;
+  }
+  getPredictionDepth() {
+    return this.predictionHistory.length;
+  }
+  get interpolationDelay() {
+    return this.interpBuffer.delay;
+  }
+  setInterpolationDelay(ms) {
+    this.interpBuffer.setDelay(ms);
+  }
+};
+
+// src/transports/memory-transport.ts
+var MemoryServerTransport = class {
+  constructor() {
+    this.peers = /* @__PURE__ */ new Map();
+    this.connectionHandler = null;
+    this.disconnectionHandler = null;
+    this.nextPeerId = 1;
+  }
+  onConnection(handler) {
+    this.connectionHandler = handler;
+  }
+  onDisconnection(handler) {
+    this.disconnectionHandler = handler;
+  }
+  getPeer(peerId) {
+    return this.peers.get(peerId);
+  }
+  getPeerIds() {
+    return [...this.peers.keys()];
+  }
+  /**
+   * Simulate a client connection. Returns the client-side adapter and
+   * the server-assigned peer id. Fires the server's connection handler
+   * synchronously; the client's `onOpen` fires on the next microtask.
+   */
+  connectClient() {
+    const peerId = `peer_${this.nextPeerId++}`;
+    const peer = new MemoryPeerTransport(peerId, this);
+    this.peers.set(peerId, peer);
+    this.connectionHandler?.(peer, peerId);
+    peer._openClient();
+    return { client: peer.clientView(), peerId };
+  }
+  /** Called by a peer when it disconnects. */
+  _peerClosed(peerId) {
+    this.peers.delete(peerId);
+    this.disconnectionHandler?.(peerId);
+  }
+  close() {
+    for (const peerId of [...this.peers.keys()]) {
+      this._peerClosed(peerId);
+    }
+  }
+};
+var MemoryPeerTransport = class {
+  constructor(peerId, server) {
+    this.peerId = peerId;
+    this.server = server;
+    this.serverMessageHandler = null;
+    this.serverCloseHandler = null;
+    this.clientMessageHandler = null;
+    this.clientCloseHandler = null;
+    this.clientOpenHandler = null;
+  }
+  // Server-side TransportAdapter
+  send(data) {
+    const copy = new Uint8Array(data);
+    queueMicrotask(() => this.clientMessageHandler?.(copy));
+  }
+  onOpen(_handler) {
+  }
+  onMessage(handler) {
+    this.serverMessageHandler = handler;
+  }
+  onClose(handler) {
+    this.serverCloseHandler = handler;
+  }
+  close() {
+    this.serverCloseHandler?.();
+    this.clientCloseHandler?.();
+    this.server._peerClosed(this.peerId);
+  }
+  /** Client-side adapter view: sends to the server, observes server messages. */
+  clientView() {
+    const self = this;
+    return {
+      send(data) {
+        const copy = new Uint8Array(data);
+        queueMicrotask(() => self.serverMessageHandler?.(copy));
+      },
+      onOpen(handler) {
+        self.clientOpenHandler = handler;
+      },
+      onMessage(handler) {
+        self.clientMessageHandler = handler;
+      },
+      onClose(handler) {
+        self.clientCloseHandler = handler;
+      },
+      close() {
+        self.clientCloseHandler?.();
+        self.serverCloseHandler?.();
+        self.server._peerClosed(self.peerId);
+      }
+    };
+  }
+  _openClient() {
+    queueMicrotask(() => this.clientOpenHandler?.());
+  }
+};
+
+// src/components/sync-spec.ts
+function networked(spec) {
+  return spec;
+}