@kikorin/netcode 1.0.0

package/dist/index.js

@@ -0,0 +1,1030 @@
+// src/types.ts
+var HEADER_SIZE = 8;
+var MessageType = /* @__PURE__ */ ((MessageType3) => {
+  MessageType3[MessageType3["Handshake"] = 1] = "Handshake";
+  MessageType3[MessageType3["Subscribe"] = 2] = "Subscribe";
+  MessageType3[MessageType3["Unsubscribe"] = 3] = "Unsubscribe";
+  MessageType3[MessageType3["DeltaUpdate"] = 4] = "DeltaUpdate";
+  MessageType3[MessageType3["FullSync"] = 5] = "FullSync";
+  MessageType3[MessageType3["Ack"] = 6] = "Ack";
+  MessageType3[MessageType3["Ping"] = 7] = "Ping";
+  MessageType3[MessageType3["Pong"] = 8] = "Pong";
+  MessageType3[MessageType3["LeadClaim"] = 9] = "LeadClaim";
+  MessageType3[MessageType3["LeadYield"] = 10] = "LeadYield";
+  MessageType3[MessageType3["PeerList"] = 11] = "PeerList";
+  MessageType3[MessageType3["GameEvent"] = 12] = "GameEvent";
+  return MessageType3;
+})(MessageType || {});
+var MessageFlag = /* @__PURE__ */ ((MessageFlag3) => {
+  MessageFlag3[MessageFlag3["None"] = 0] = "None";
+  MessageFlag3[MessageFlag3["Reliable"] = 1] = "Reliable";
+  MessageFlag3[MessageFlag3["Compressed"] = 2] = "Compressed";
+  MessageFlag3[MessageFlag3["Fragmented"] = 4] = "Fragmented";
+  return MessageFlag3;
+})(MessageFlag || {});
+
+// src/change-tracker.ts
+var ChangeTracker = class {
+  constructor() {
+    this._schemas = /* @__PURE__ */ new Map();
+    // Flat snapshot per entity (reused across components)
+    this._snapshots = /* @__PURE__ */ new Map();
+    this._dirtySet = /* @__PURE__ */ new Set();
+  }
+  registerComponent(schema) {
+    if (this._schemas.has(schema.id)) {
+      throw new Error(`Component id ${schema.id} already registered`);
+    }
+    this._schemas.set(schema.id, schema);
+  }
+  unregisterComponent(componentId) {
+    this._schemas.delete(componentId);
+    for (const snap of this._snapshots.values()) {
+      snap.delete(componentId);
+    }
+  }
+  markDirty(entityId) {
+    this._dirtySet.add(entityId);
+  }
+  markDirtyBatch(entities) {
+    for (const eid of entities) this._dirtySet.add(eid);
+  }
+  get dirtyCount() {
+    return this._dirtySet.size;
+  }
+  /**
+   * Compute deltas for a subset of entities and update the snapshot.
+   * Only entities that were marked dirty are compared; clean entities are skipped.
+   * Clears dirty flags for all entities in the provided list.
+   */
+  flush(entities) {
+    const deltas = [];
+    for (const eid of entities) {
+      if (!this._dirtySet.has(eid)) continue;
+      let entitySnap = this._snapshots.get(eid);
+      if (!entitySnap) {
+        entitySnap = /* @__PURE__ */ new Map();
+        this._snapshots.set(eid, entitySnap);
+      }
+      for (const [cid, schema] of this._schemas) {
+        const fieldCount = schema.fields.length;
+        let compSnap = entitySnap.get(cid);
+        if (!compSnap) {
+          compSnap = new Float64Array(fieldCount).fill(NaN);
+          entitySnap.set(cid, compSnap);
+        }
+        for (let fi = 0; fi < fieldCount; fi++) {
+          const field = schema.fields[fi];
+          const cur = field.array[eid];
+          if (!Object.is(compSnap[fi], cur)) {
+            compSnap[fi] = cur;
+            deltas.push({ entityId: eid, componentId: cid, fieldId: fi, value: cur });
+          }
+        }
+      }
+      this._dirtySet.delete(eid);
+    }
+    return deltas;
+  }
+  /**
+   * Force-flush all registered fields for the given entities, ignoring dirty state.
+   * Use when a new peer joins and needs a full state sync.
+   */
+  fullSnapshot(entities) {
+    const deltas = [];
+    for (const eid of entities) {
+      for (const [cid, schema] of this._schemas) {
+        for (let fi = 0; fi < schema.fields.length; fi++) {
+          deltas.push({
+            entityId: eid,
+            componentId: cid,
+            fieldId: fi,
+            value: schema.fields[fi].array[eid]
+          });
+        }
+      }
+    }
+    return deltas;
+  }
+  /**
+   * Invalidate the snapshot for an entity (e.g. after it is destroyed and respawned).
+   * Next flush will treat all fields as changed.
+   */
+  invalidateEntity(entityId) {
+    this._snapshots.delete(entityId);
+    this._dirtySet.add(entityId);
+  }
+  clearDirtyAll() {
+    this._dirtySet.clear();
+  }
+};
+
+// src/connection-pool.ts
+var _ConnectionPool = class _ConnectionPool {
+  constructor() {
+    this._peer = null;
+    this._conns = /* @__PURE__ */ new Map();
+    this._handlers = /* @__PURE__ */ new Set();
+    this._disconnectHandlers = /* @__PURE__ */ new Set();
+    // Reconnect state: peerId → current delay ms
+    this._reconnectDelay = /* @__PURE__ */ new Map();
+    this._reconnectHandles = /* @__PURE__ */ new Map();
+  }
+  setPeer(peer) {
+    this._peer = peer;
+    peer.on("connection", (conn) => this._registerConn(conn.peer, conn));
+  }
+  async connect(peerId) {
+    const existing = this._conns.get(peerId);
+    if (existing?.state === "open") return;
+    if (existing?.state === "pending") return existing.openPromise;
+    if (!this._peer) throw new Error("Peer not initialized \u2014 call setPeer() first");
+    const conn = this._peer.connect(peerId, { reliable: false, serialization: "binary" });
+    this._registerConn(peerId, conn);
+    return this._conns.get(peerId).openPromise;
+  }
+  send(peerId, data) {
+    const managed = this._conns.get(peerId);
+    if (!managed) {
+      void this.connect(peerId).then(() => this.send(peerId, data)).catch(() => {
+      });
+      return;
+    }
+    if (managed.state === "open") {
+      managed.conn.send(data);
+    } else {
+      managed.queue.push(data);
+    }
+  }
+  isOpen(peerId) {
+    return this._conns.get(peerId)?.state === "open";
+  }
+  disconnect(peerId) {
+    clearTimeout(this._reconnectHandles.get(peerId));
+    this._reconnectHandles.delete(peerId);
+    this._reconnectDelay.delete(peerId);
+    const managed = this._conns.get(peerId);
+    if (managed) {
+      managed.conn.close();
+      this._conns.delete(peerId);
+    }
+  }
+  onData(handler) {
+    this._handlers.add(handler);
+    return () => this._handlers.delete(handler);
+  }
+  /** Fires when a connection closes unexpectedly (not from a local disconnect() call). */
+  onDisconnect(handler) {
+    this._disconnectHandlers.add(handler);
+    return () => this._disconnectHandlers.delete(handler);
+  }
+  dispose() {
+    for (const h of this._reconnectHandles.values()) clearTimeout(h);
+    this._reconnectHandles.clear();
+    for (const m of this._conns.values()) m.conn.close();
+    this._conns.clear();
+    this._peer?.destroy();
+    this._peer = null;
+  }
+  // ---------------------------------------------------------------------------
+  _registerConn(peerId, conn) {
+    const existing = this._conns.get(peerId);
+    if (existing?.state === "open") return;
+    let resolve;
+    let reject;
+    const openPromise = new Promise((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    const managed = { conn, state: "pending", queue: [], resolve, reject, openPromise };
+    this._conns.set(peerId, managed);
+    conn.on("open", () => {
+      managed.state = "open";
+      this._reconnectDelay.delete(peerId);
+      clearTimeout(this._reconnectHandles.get(peerId));
+      this._reconnectHandles.delete(peerId);
+      for (const buf of managed.queue) conn.send(buf);
+      managed.queue = [];
+      resolve();
+    });
+    conn.on("data", (raw) => {
+      const buf = raw instanceof ArrayBuffer ? raw : raw instanceof Uint8Array ? raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.byteLength) : null;
+      if (!buf) return;
+      for (const h of this._handlers) h(buf, peerId);
+    });
+    conn.on("close", () => {
+      managed.state = "closed";
+      for (const h of this._disconnectHandlers) h(peerId);
+      this._scheduleReconnect(peerId);
+    });
+    conn.on("error", (err) => {
+      managed.state = "error";
+      reject(err);
+      this._scheduleReconnect(peerId);
+    });
+  }
+  _scheduleReconnect(peerId) {
+    if (!this._peer) return;
+    const prev = this._reconnectDelay.get(peerId) ?? _ConnectionPool.BASE_DELAY / 2;
+    const delay = Math.min(prev * 2, _ConnectionPool.MAX_DELAY);
+    this._reconnectDelay.set(peerId, delay);
+    clearTimeout(this._reconnectHandles.get(peerId));
+    const handle = setTimeout(() => {
+      if (this._conns.get(peerId)?.state !== "open") {
+        void this.connect(peerId).catch(() => {
+        });
+      }
+    }, delay);
+    this._reconnectHandles.set(peerId, handle);
+  }
+};
+_ConnectionPool.BASE_DELAY = 500;
+_ConnectionPool.MAX_DELAY = 3e4;
+var ConnectionPool = _ConnectionPool;
+
+// src/message-codec.ts
+var POOL_BUFFER_SIZE = 65536;
+var POOL_MAX = 16;
+var _pool = [];
+function acquireBuffer() {
+  return _pool.pop() ?? new ArrayBuffer(POOL_BUFFER_SIZE);
+}
+function releaseBuffer(buf) {
+  if (buf.byteLength === POOL_BUFFER_SIZE && _pool.length < POOL_MAX) {
+    _pool.push(buf);
+  }
+}
+function encodeHeader(view, type, flags, seq, ack, payloadLen) {
+  view.setUint8(0, type);
+  view.setUint8(1, flags);
+  view.setUint16(2, seq, true);
+  view.setUint16(4, ack, true);
+  view.setUint16(6, payloadLen, true);
+}
+function decodeHeader(view) {
+  return {
+    type: view.getUint8(0),
+    flags: view.getUint8(1),
+    seq: view.getUint16(2, true),
+    ack: view.getUint16(4, true),
+    payloadLen: view.getUint16(6, true)
+  };
+}
+function encodeMessage(msg) {
+  const payloadLen = msg.payload.byteLength;
+  const total = HEADER_SIZE + payloadLen;
+  const buf = total <= POOL_BUFFER_SIZE ? acquireBuffer() : new ArrayBuffer(total);
+  encodeHeader(new DataView(buf), msg.type, msg.flags, msg.seq, msg.ack, payloadLen);
+  new Uint8Array(buf, HEADER_SIZE, payloadLen).set(new Uint8Array(msg.payload));
+  const out = buf.slice(0, total);
+  releaseBuffer(buf);
+  return out;
+}
+function decodeMessage(buf) {
+  const view = new DataView(buf);
+  const { type, flags, seq, ack, payloadLen } = decodeHeader(view);
+  return {
+    type,
+    flags,
+    seq,
+    ack,
+    payload: buf.slice(HEADER_SIZE, HEADER_SIZE + payloadLen)
+  };
+}
+function encodeDeltaPayload(groupId, deltas) {
+  const enc = new TextEncoder();
+  const groupIdBytes = enc.encode(groupId);
+  const byEntity = /* @__PURE__ */ new Map();
+  for (const { entityId, componentId, fieldId, value } of deltas) {
+    let byComp = byEntity.get(entityId);
+    if (!byComp) {
+      byComp = /* @__PURE__ */ new Map();
+      byEntity.set(entityId, byComp);
+    }
+    let fields = byComp.get(componentId);
+    if (!fields) {
+      fields = [];
+      byComp.set(componentId, fields);
+    }
+    fields.push([fieldId, value]);
+  }
+  const maxSize = 1 + groupIdBytes.length + 2 + deltas.length * 12;
+  const buf = maxSize <= POOL_BUFFER_SIZE ? acquireBuffer() : new ArrayBuffer(maxSize);
+  const view = new DataView(buf);
+  let off = 0;
+  view.setUint8(off, groupIdBytes.length);
+  off += 1;
+  new Uint8Array(buf, off, groupIdBytes.length).set(groupIdBytes);
+  off += groupIdBytes.length;
+  view.setUint16(off, byEntity.size, true);
+  off += 2;
+  for (const [eid, byComp] of byEntity) {
+    view.setUint32(off, eid, true);
+    off += 4;
+    view.setUint8(off, byComp.size);
+    off += 1;
+    for (const [cid, fields] of byComp) {
+      view.setUint8(off, cid);
+      off += 1;
+      view.setUint8(off, fields.length);
+      off += 1;
+      for (const [fid, val] of fields) {
+        view.setUint8(off, fid);
+        off += 1;
+        view.setFloat32(off, val, true);
+        off += 4;
+      }
+    }
+  }
+  const out = buf.slice(0, off);
+  releaseBuffer(buf);
+  return out;
+}
+function decodeDeltaPayload(buf) {
+  const view = new DataView(buf);
+  const dec = new TextDecoder();
+  let off = 0;
+  const groupIdLen = view.getUint8(off);
+  off += 1;
+  const groupId = dec.decode(buf.slice(off, off + groupIdLen));
+  off += groupIdLen;
+  const entityCount = view.getUint16(off, true);
+  off += 2;
+  const deltas = [];
+  for (let e = 0; e < entityCount; e++) {
+    const entityId = view.getUint32(off, true);
+    off += 4;
+    const componentCount = view.getUint8(off);
+    off += 1;
+    for (let c = 0; c < componentCount; c++) {
+      const componentId = view.getUint8(off);
+      off += 1;
+      const fieldCount = view.getUint8(off);
+      off += 1;
+      for (let f = 0; f < fieldCount; f++) {
+        const fieldId = view.getUint8(off);
+        off += 1;
+        const value = view.getFloat32(off, true);
+        off += 4;
+        deltas.push({ entityId, componentId, fieldId, value });
+      }
+    }
+  }
+  return { groupId, deltas };
+}
+var _enc = new TextEncoder();
+var _dec = new TextDecoder();
+function encodeJson(obj) {
+  return _enc.encode(JSON.stringify(obj)).buffer;
+}
+function decodeJson(buf) {
+  return JSON.parse(_dec.decode(buf));
+}
+
+// src/lead-election.ts
+function fnv1a(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619) >>> 0;
+  }
+  return h;
+}
+var LeadElector = class {
+  constructor(strategy = "min-id") {
+    this._loadInfo = /* @__PURE__ */ new Map();
+    this._strategy = strategy;
+  }
+  updateLoadInfo(info) {
+    this._loadInfo.set(info.peerId, info);
+  }
+  removeLoadInfo(peerId) {
+    this._loadInfo.delete(peerId);
+  }
+  electLead(groupId, candidates) {
+    if (candidates.length === 0) throw new Error("No candidates for election");
+    if (candidates.length === 1) return candidates[0];
+    switch (this._strategy) {
+      case "min-id":
+        return this._minId(candidates);
+      case "hash-ring":
+        return this._hashRing(groupId, candidates);
+      case "load-balanced":
+        return this._loadBalanced(candidates);
+    }
+  }
+  wouldReelect(groupId, currentLead, candidates) {
+    try {
+      return this.electLead(groupId, candidates) !== currentLead;
+    } catch {
+      return true;
+    }
+  }
+  _minId(candidates) {
+    return candidates.reduce((best, id) => id < best ? id : best);
+  }
+  _hashRing(groupId, candidates) {
+    const target = fnv1a(groupId);
+    const ring = [];
+    for (const peerId of candidates) {
+      for (let v = 0; v < 20; v++) {
+        ring.push({ pos: fnv1a(`${peerId}:vn${v}`), peerId });
+      }
+    }
+    ring.sort((a, b) => a.pos < b.pos ? -1 : a.pos > b.pos ? 1 : 0);
+    return (ring.find((n) => n.pos >= target) ?? ring[0]).peerId;
+  }
+  _loadBalanced(candidates) {
+    let best = candidates[0];
+    let bestScore = Infinity;
+    for (const peerId of candidates) {
+      const info = this._loadInfo.get(peerId);
+      const score = info ? info.connectionCount * 2 + info.leadGroupCount * 5 : 0;
+      if (score < bestScore) {
+        bestScore = score;
+        best = peerId;
+      }
+    }
+    return best;
+  }
+};
+
+// src/interest-group.ts
+var InterestGroup = class {
+  constructor(config, localPeerId) {
+    this._peers = /* @__PURE__ */ new Map();
+    this._leadId = null;
+    this._sendFn = null;
+    this._deltaHandlers = /* @__PURE__ */ new Set();
+    this._pending = [];
+    this._tickHandle = null;
+    this._seq = 0;
+    this._ack = 0;
+    this.id = config.id;
+    this._config = {
+      id: config.id,
+      maxEntities: config.maxEntities ?? 4096,
+      tickRateMs: config.tickRateMs ?? 50,
+      electionStrategy: config.electionStrategy ?? "min-id"
+    };
+    this._localPeerId = localPeerId;
+    this._elector = new LeadElector(this._config.electionStrategy);
+  }
+  // ---------------------------------------------------------------------------
+  // Accessors
+  // ---------------------------------------------------------------------------
+  get leadId() {
+    return this._leadId;
+  }
+  get isLead() {
+    return this._leadId === this._localPeerId;
+  }
+  get peerCount() {
+    return this._peers.size;
+  }
+  getPeer(peerId) {
+    return this._peers.get(peerId);
+  }
+  get peerIds() {
+    return new Set(this._peers.keys());
+  }
+  // ---------------------------------------------------------------------------
+  // Wiring
+  // ---------------------------------------------------------------------------
+  setSendFn(fn) {
+    this._sendFn = fn;
+  }
+  // ---------------------------------------------------------------------------
+  // Membership
+  // ---------------------------------------------------------------------------
+  addPeer(peerId) {
+    if (this._peers.has(peerId)) return;
+    this._peers.set(peerId, {
+      peerId,
+      isLead: false,
+      joinedAt: Date.now(),
+      lastSeenAt: Date.now(),
+      rttMs: 0
+    });
+    this._reelect();
+  }
+  removePeer(peerId) {
+    if (!this._peers.has(peerId)) return;
+    this._peers.delete(peerId);
+    this._elector.removeLoadInfo(peerId);
+    if (this._leadId === peerId) {
+      this._leadId = null;
+      this._reelect();
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Delta publishing
+  // ---------------------------------------------------------------------------
+  /** Queue deltas to be sent on the next tick flush */
+  publishDeltas(deltas) {
+    if (deltas.length > 0) this._pending.push(...deltas);
+  }
+  /** Send all pending deltas immediately (called by the tick interval) */
+  flush() {
+    if (this._pending.length === 0 || !this._sendFn) return;
+    const payload = encodeDeltaPayload(this.id, this._pending);
+    this._pending = [];
+    const msg = {
+      type: 4 /* DeltaUpdate */,
+      flags: 0 /* None */,
+      seq: this._nextSeq(),
+      ack: this._ack,
+      payload
+    };
+    if (this.isLead) {
+      for (const peerId of this._peers.keys()) {
+        this._sendFn(peerId, msg);
+      }
+    } else if (this._leadId !== null) {
+      this._sendFn(this._leadId, msg);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Inbound message dispatch
+  // ---------------------------------------------------------------------------
+  handleMessage(msg, fromPeer) {
+    const state = this._peers.get(fromPeer);
+    if (state) state.lastSeenAt = Date.now();
+    this._ack = msg.seq;
+    switch (msg.type) {
+      case 4 /* DeltaUpdate */:
+        this._onDeltaUpdate(msg, fromPeer);
+        break;
+      case 5 /* FullSync */:
+        this._onFullSync(msg, fromPeer);
+        break;
+      case 9 /* LeadClaim */:
+        this._onLeadClaim(msg);
+        break;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Handler registration
+  // ---------------------------------------------------------------------------
+  onDelta(handler) {
+    this._deltaHandlers.add(handler);
+    return () => this._deltaHandlers.delete(handler);
+  }
+  // ---------------------------------------------------------------------------
+  // Tick control
+  // ---------------------------------------------------------------------------
+  startTick() {
+    if (this._tickHandle !== null) return;
+    this._tickHandle = setInterval(() => this.flush(), this._config.tickRateMs);
+  }
+  stopTick() {
+    if (this._tickHandle !== null) {
+      clearInterval(this._tickHandle);
+      this._tickHandle = null;
+    }
+  }
+  dispose() {
+    this.stopTick();
+    this._deltaHandlers.clear();
+    this._peers.clear();
+  }
+  // ---------------------------------------------------------------------------
+  // Private
+  // ---------------------------------------------------------------------------
+  _reelect() {
+    if (this._peers.size === 0) {
+      this._leadId = this._localPeerId;
+      return;
+    }
+    const candidates = [this._localPeerId, ...this._peers.keys()];
+    const newLead = this._elector.electLead(this.id, candidates);
+    if (newLead !== this._leadId) {
+      this._leadId = newLead;
+      if (newLead === this._localPeerId) {
+        this._broadcastLeadClaim();
+      }
+    }
+  }
+  _broadcastLeadClaim() {
+    if (!this._sendFn) return;
+    const payload = encodeJson({ groupId: this.id, leadId: this._localPeerId });
+    const msg = {
+      type: 9 /* LeadClaim */,
+      flags: 1 /* Reliable */,
+      seq: this._nextSeq(),
+      ack: this._ack,
+      payload
+    };
+    for (const peerId of this._peers.keys()) {
+      this._sendFn(peerId, msg);
+    }
+  }
+  _onDeltaUpdate(msg, fromPeer) {
+    let groupId;
+    let deltas;
+    try {
+      ;
+      ({ groupId, deltas } = decodeDeltaPayload(msg.payload));
+    } catch {
+      return;
+    }
+    if (groupId !== this.id) return;
+    if (this.isLead && this._sendFn) {
+      for (const peerId of this._peers.keys()) {
+        if (peerId !== fromPeer) this._sendFn(peerId, msg);
+      }
+    }
+    for (const h of this._deltaHandlers) h(deltas, this.id, fromPeer);
+  }
+  _onFullSync(msg, fromPeer) {
+    let groupId;
+    let deltas;
+    try {
+      ;
+      ({ groupId, deltas } = decodeDeltaPayload(msg.payload));
+    } catch {
+      return;
+    }
+    if (groupId !== this.id) return;
+    for (const h of this._deltaHandlers) h(deltas, this.id, fromPeer);
+  }
+  _onLeadClaim(msg) {
+    try {
+      const { groupId, leadId } = decodeJson(msg.payload);
+      if (groupId !== this.id || typeof leadId !== "string") return;
+      if (this._peers.has(leadId) || leadId === this._localPeerId) {
+        this._leadId = leadId;
+        for (const [pid, state] of this._peers) state.isLead = pid === leadId;
+      }
+    } catch {
+    }
+  }
+  _nextSeq() {
+    return this._seq = this._seq + 1 & 65535;
+  }
+};
+
+// src/peer-net.ts
+var PeerNet = class {
+  constructor(config) {
+    this._groups = /* @__PURE__ */ new Map();
+    this._tracker = new ChangeTracker();
+    this._seq = 0;
+    this._ack = 0;
+    this._rttMs = 50;
+    this._gameEventHandlers = [];
+    this.localPeerId = config.peerId;
+    this._config = {
+      peerId: config.peerId,
+      rttAlpha: config.rttAlpha ?? 0.125
+    };
+    this._pool = new ConnectionPool();
+    this._pool.onData((buf, from) => this._onRawData(buf, from));
+    this._pool.onDisconnect((peerId) => {
+      for (const group of this._groups.values()) group.removePeer(peerId);
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // PeerJS wiring
+  // ---------------------------------------------------------------------------
+  /** Attach the live PeerJS Peer instance after it opens. */
+  attachPeer(peer) {
+    this._pool.setPeer(peer);
+  }
+  // ---------------------------------------------------------------------------
+  // Component schema
+  // ---------------------------------------------------------------------------
+  registerComponent(schema) {
+    this._tracker.registerComponent(schema);
+  }
+  unregisterComponent(componentId) {
+    this._tracker.unregisterComponent(componentId);
+  }
+  // ---------------------------------------------------------------------------
+  // Group management
+  // ---------------------------------------------------------------------------
+  createGroup(config) {
+    const existing = this._groups.get(config.id);
+    if (existing) return existing;
+    const group = new InterestGroup(config, this.localPeerId);
+    group.setSendFn((to, msg) => this._send(to, msg));
+    group.startTick();
+    this._groups.set(config.id, group);
+    return group;
+  }
+  destroyGroup(groupId) {
+    const group = this._groups.get(groupId);
+    if (!group) return;
+    group.dispose();
+    this._groups.delete(groupId);
+  }
+  getGroup(groupId) {
+    return this._groups.get(groupId);
+  }
+  // ---------------------------------------------------------------------------
+  // Peer connections
+  // ---------------------------------------------------------------------------
+  async connectPeer(peerId) {
+    await this._pool.connect(peerId);
+  }
+  disconnectPeer(peerId) {
+    this._pool.disconnect(peerId);
+    for (const group of this._groups.values()) {
+      group.removePeer(peerId);
+    }
+  }
+  onPeerDisconnect(handler) {
+    return this._pool.onDisconnect(handler);
+  }
+  sendGameEvent(peerId, payload) {
+    this._send(peerId, {
+      type: 12 /* GameEvent */,
+      flags: 0 /* None */,
+      seq: this._nextSeq(),
+      ack: this._ack,
+      payload
+    });
+  }
+  onGameEvent(handler) {
+    this._gameEventHandlers.push(handler);
+    return () => {
+      const idx = this._gameEventHandlers.indexOf(handler);
+      if (idx !== -1) this._gameEventHandlers.splice(idx, 1);
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Group subscriptions
+  // ---------------------------------------------------------------------------
+  /**
+   * Subscribe the local peer to a group and introduce remote peers.
+   * Sends a Subscribe control message to each remote peer.
+   */
+  joinGroup(groupId, remotePeers) {
+    const group = this._requireGroup(groupId);
+    for (const p of remotePeers) group.addPeer(p);
+    this._sendSubscribe(groupId, remotePeers);
+  }
+  /**
+   * Leave a group: notify remote peers and remove local state.
+   */
+  leaveGroup(groupId) {
+    const group = this._groups.get(groupId);
+    if (!group) return;
+    const peers = [...group.peerIds];
+    this._sendUnsubscribe(groupId, peers);
+    for (const p of peers) group.removePeer(p);
+  }
+  // ---------------------------------------------------------------------------
+  // Delta pipeline
+  // ---------------------------------------------------------------------------
+  markEntityDirty(entityId) {
+    this._tracker.markDirty(entityId);
+  }
+  markEntitiesDirty(entities) {
+    this._tracker.markDirtyBatch(entities);
+  }
+  invalidateEntity(entityId) {
+    this._tracker.invalidateEntity(entityId);
+  }
+  /**
+   * Compute deltas for dirty entities and push them into the group's send queue.
+   * The group's tick interval handles the actual sending.
+   *
+   * Call once per game tick, after ECS systems run.
+   */
+  flushGroupDeltas(groupId, entities) {
+    const group = this._groups.get(groupId);
+    if (!group) return;
+    const deltas = this._tracker.flush(entities);
+    if (deltas.length > 0) group.publishDeltas(deltas);
+  }
+  /**
+   * Send a full-state sync to a newly joined peer for a given group.
+   * Generates a snapshot of all registered component fields for all provided entities.
+   */
+  sendFullSync(groupId, toPeer, entities) {
+    const group = this._groups.get(groupId);
+    if (!group) return;
+    const deltas = this._tracker.fullSnapshot(entities);
+    if (deltas.length === 0) return;
+    const payload = encodeDeltaPayload(groupId, deltas);
+    this._send(toPeer, {
+      type: 5 /* FullSync */,
+      flags: 1 /* Reliable */,
+      seq: this._nextSeq(),
+      ack: this._ack,
+      payload
+    });
+  }
+  onGroupDelta(groupId, handler) {
+    return this._requireGroup(groupId).onDelta(handler);
+  }
+  // ---------------------------------------------------------------------------
+  // Diagnostics
+  // ---------------------------------------------------------------------------
+  get rttMs() {
+    return this._rttMs;
+  }
+  get dirtyEntityCount() {
+    return this._tracker.dirtyCount;
+  }
+  ping(peerId) {
+    const buf = new ArrayBuffer(8);
+    new DataView(buf).setFloat64(0, performance.now(), true);
+    this._send(peerId, {
+      type: 7 /* Ping */,
+      flags: 0 /* None */,
+      seq: this._nextSeq(),
+      ack: this._ack,
+      payload: buf
+    });
+  }
+  // ---------------------------------------------------------------------------
+  // Teardown
+  // ---------------------------------------------------------------------------
+  dispose() {
+    for (const group of this._groups.values()) group.dispose();
+    this._groups.clear();
+    this._pool.dispose();
+  }
+  // ---------------------------------------------------------------------------
+  // Private routing
+  // ---------------------------------------------------------------------------
+  _onRawData(buf, from) {
+    let msg;
+    try {
+      msg = decodeMessage(buf);
+    } catch {
+      return;
+    }
+    this._ack = msg.seq;
+    switch (msg.type) {
+      case 2 /* Subscribe */: {
+        this._onSubscribe(msg, from);
+        break;
+      }
+      case 3 /* Unsubscribe */: {
+        this._onUnsubscribe(msg, from);
+        break;
+      }
+      case 4 /* DeltaUpdate */:
+      case 5 /* FullSync */:
+      case 9 /* LeadClaim */: {
+        for (const group of this._groups.values()) {
+          if (group.peerIds.has(from)) group.handleMessage(msg, from);
+        }
+        break;
+      }
+      case 12 /* GameEvent */: {
+        for (const h of this._gameEventHandlers) h(msg.payload, from);
+        break;
+      }
+      case 7 /* Ping */: {
+        this._send(from, {
+          type: 8 /* Pong */,
+          flags: 0 /* None */,
+          seq: this._nextSeq(),
+          ack: this._ack,
+          payload: msg.payload
+        });
+        break;
+      }
+      case 8 /* Pong */: {
+        try {
+          const sent = new DataView(msg.payload).getFloat64(0, true);
+          const rtt = performance.now() - sent;
+          this._rttMs += this._config.rttAlpha * (rtt - this._rttMs);
+        } catch {
+        }
+        break;
+      }
+    }
+  }
+  _onSubscribe(msg, from) {
+    try {
+      const { groupId } = decodeJson(msg.payload);
+      if (typeof groupId === "string") this._groups.get(groupId)?.addPeer(from);
+    } catch {
+    }
+  }
+  _onUnsubscribe(msg, from) {
+    try {
+      const { groupId } = decodeJson(msg.payload);
+      if (typeof groupId === "string") this._groups.get(groupId)?.removePeer(from);
+    } catch {
+    }
+  }
+  _sendSubscribe(groupId, peers) {
+    const payload = encodeJson({ groupId });
+    const msg = {
+      type: 2 /* Subscribe */,
+      flags: 1 /* Reliable */,
+      seq: this._nextSeq(),
+      ack: this._ack,
+      payload
+    };
+    for (const p of peers) this._send(p, msg);
+  }
+  _sendUnsubscribe(groupId, peers) {
+    const payload = encodeJson({ groupId });
+    const msg = {
+      type: 3 /* Unsubscribe */,
+      flags: 1 /* Reliable */,
+      seq: this._nextSeq(),
+      ack: this._ack,
+      payload
+    };
+    for (const p of peers) this._send(p, msg);
+  }
+  _send(to, msg) {
+    this._pool.send(to, encodeMessage(msg));
+  }
+  _nextSeq() {
+    return this._seq = this._seq + 1 & 65535;
+  }
+  _requireGroup(groupId) {
+    const group = this._groups.get(groupId);
+    if (!group) throw new Error(`Interest group "${groupId}" not found \u2014 call createGroup() first`);
+    return group;
+  }
+};
+
+// src/priority-queue.ts
+var PriorityQueue = class {
+  constructor() {
+    this._heap = [];
+    this._seq = 0;
+  }
+  get size() {
+    return this._heap.length;
+  }
+  get isEmpty() {
+    return this._heap.length === 0;
+  }
+  push(value, priority) {
+    const entry = { priority, seq: this._seq++, value };
+    this._heap.push(entry);
+    this._bubbleUp(this._heap.length - 1);
+  }
+  pop() {
+    if (this._heap.length === 0) return void 0;
+    const top = this._heap[0];
+    const last = this._heap.pop();
+    if (this._heap.length > 0) {
+      this._heap[0] = last;
+      this._siftDown(0);
+    }
+    return top.value;
+  }
+  peek() {
+    return this._heap[0]?.value;
+  }
+  clear() {
+    this._heap = [];
+  }
+  _lt(a, b) {
+    return a.priority !== b.priority ? a.priority < b.priority : a.seq < b.seq;
+  }
+  _bubbleUp(i) {
+    while (i > 0) {
+      const parent = i - 1 >> 1;
+      if (this._lt(this._heap[i], this._heap[parent])) {
+        ;
+        [this._heap[i], this._heap[parent]] = [this._heap[parent], this._heap[i]];
+        i = parent;
+      } else break;
+    }
+  }
+  _siftDown(i) {
+    const n = this._heap.length;
+    for (; ; ) {
+      let min = i;
+      const l = (i << 1) + 1;
+      const r = l + 1;
+      if (l < n && this._lt(this._heap[l], this._heap[min])) min = l;
+      if (r < n && this._lt(this._heap[r], this._heap[min])) min = r;
+      if (min === i) break;
+      [this._heap[i], this._heap[min]] = [this._heap[min], this._heap[i]];
+      i = min;
+    }
+  }
+};
+export {
+  ChangeTracker,
+  HEADER_SIZE,
+  InterestGroup,
+  LeadElector,
+  MessageFlag,
+  MessageType,
+  PeerNet,
+  PriorityQueue,
+  decodeDeltaPayload,
+  decodeHeader,
+  decodeJson,
+  decodeMessage,
+  encodeDeltaPayload,
+  encodeHeader,
+  encodeJson,
+  encodeMessage
+};
+//# sourceMappingURL=index.js.map