@carverjs/multiplayer 0.0.1

package/dist/sync.js

@@ -0,0 +1,845 @@
+"use strict";
+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/sync/index.ts
+var sync_exports = {};
+__export(sync_exports, {
+  EventSync: () => EventSync,
+  PredictionSync: () => PredictionSync,
+  SnapshotSync: () => SnapshotSync
+});
+module.exports = __toCommonJS(sync_exports);
+
+// src/sync/EventSync.ts
+var EventSync = class {
+  constructor(transport, options) {
+    this._handlers = /* @__PURE__ */ new Map();
+    this._transport = transport;
+    this._hostValidation = options?.hostValidation ?? false;
+    this._channel = transport.createChannel("carver:events", {
+      reliable: true,
+      ordered: true
+    });
+    this._channel.onReceive((rawData, peerId) => {
+      try {
+        const packet = typeof rawData === "string" ? JSON.parse(rawData) : rawData;
+        if (this._hostValidation && this._transport.isHost && packet.sender !== this._transport.peerId) {
+          const targets = Array.from(this._transport.peers).filter((p) => p !== peerId);
+          if (targets.length > 0) {
+            this._channel.send(JSON.stringify(packet), targets);
+          }
+        }
+        if (this._hostValidation && !this._transport.isHost && peerId !== this._transport.hostId) {
+          return;
+        }
+        const handlers = this._handlers.get(packet.type);
+        if (handlers) {
+          for (const handler of handlers) {
+            handler(packet.payload, packet.sender);
+          }
+        }
+      } catch {
+      }
+    });
+  }
+  /**
+   * Send a typed event to a specific peer or all peers.
+   */
+  sendEvent(type, payload, target) {
+    const packet = {
+      type,
+      payload,
+      sender: this._transport.peerId,
+      target
+    };
+    const serialized = JSON.stringify(packet);
+    if (this._hostValidation && !this._transport.isHost) {
+      this._channel.send(serialized, this._transport.hostId);
+    } else if (target) {
+      this._channel.send(serialized, target);
+    } else {
+      this._channel.send(serialized);
+    }
+  }
+  /**
+   * Broadcast a typed event to all connected peers.
+   */
+  broadcast(type, payload) {
+    this.sendEvent(type, payload);
+  }
+  /**
+   * Register a handler for a specific event type.
+   * Returns an unsubscribe function.
+   */
+  onEvent(type, callback) {
+    let handlers = this._handlers.get(type);
+    if (!handlers) {
+      handlers = [];
+      this._handlers.set(type, handlers);
+    }
+    handlers.push(callback);
+    return () => {
+      const arr = this._handlers.get(type);
+      if (arr) {
+        const idx = arr.indexOf(callback);
+        if (idx >= 0) arr.splice(idx, 1);
+        if (arr.length === 0) this._handlers.delete(type);
+      }
+    };
+  }
+  /**
+   * Clean up the event channel.
+   */
+  destroy() {
+    this._channel.close();
+    this._handlers.clear();
+  }
+};
+
+// src/core/HostAuthority.ts
+var HostAuthority = class {
+  constructor(transport, codec, snapshotBuffer, options) {
+    this._tick = 0;
+    this._broadcastAccumulator = 0;
+    // Per-client last ACK'd tick for delta compression
+    this._clientBaselines = /* @__PURE__ */ new Map();
+    // Per-client last keyframe tick for scheduling
+    this._clientLastKeyframeTick = /* @__PURE__ */ new Map();
+    // Interest management callback (optional)
+    this._interestFilter = null;
+    this._transport = transport;
+    this._codec = codec;
+    this._snapshotBuffer = snapshotBuffer;
+    this._broadcastRate = options?.broadcastRate ?? 20;
+    this._keyframeInterval = options?.keyframeInterval ?? 300;
+    this._snapshotChannel = transport.createChannel(
+      "carver:snapshots",
+      {
+        reliable: false,
+        ordered: false,
+        maxRetransmits: 0
+      }
+    );
+    this._ackChannel = transport.createChannel("carver:acks", {
+      reliable: true,
+      ordered: true
+    });
+    this._ackChannel.onReceive((data, peerId) => {
+      try {
+        const ackTick = typeof data === "string" ? parseInt(data, 10) : data;
+        if (ackTick === -1) {
+          this._clientBaselines.delete(peerId);
+        } else {
+          this._clientBaselines.set(peerId, ackTick);
+        }
+      } catch {
+      }
+    });
+    transport.onPeerJoin((peerId) => {
+      this._clientBaselines.delete(peerId);
+    });
+    transport.onPeerLeave((peerId) => {
+      this._clientBaselines.delete(peerId);
+    });
+  }
+  /** Set optional interest management filter */
+  setInterestFilter(filter) {
+    this._interestFilter = filter;
+  }
+  /**
+   * Called every fixed tick by the sync engine.
+   * Collects entity states and decides whether to broadcast.
+   */
+  tick(currentTick, entities, delta) {
+    this._tick = currentTick;
+    this._snapshotBuffer.store(currentTick, new Map(entities));
+    this._broadcastAccumulator += delta;
+    const broadcastInterval = 1 / this._broadcastRate;
+    if (this._broadcastAccumulator < broadcastInterval) return;
+    this._broadcastAccumulator -= broadcastInterval;
+    for (const peerId of this._transport.peers) {
+      this._broadcastToClient(peerId, currentTick, entities);
+    }
+  }
+  /** Force a keyframe broadcast to all clients (e.g., after host migration) */
+  forceKeyframe(currentTick, entities) {
+    this._clientBaselines.clear();
+    this._clientLastKeyframeTick.clear();
+    this._snapshotBuffer.store(currentTick, new Map(entities));
+    for (const peerId of this._transport.peers) {
+      this._broadcastToClient(peerId, currentTick, entities);
+    }
+  }
+  destroy() {
+    this._snapshotChannel.close();
+    this._ackChannel.close();
+    this._clientBaselines.clear();
+    this._clientLastKeyframeTick.clear();
+  }
+  _broadcastToClient(peerId, currentTick, entities) {
+    let clientEntities = entities;
+    if (this._interestFilter) {
+      clientEntities = /* @__PURE__ */ new Map();
+      for (const [id, entity] of entities) {
+        if (this._interestFilter(id, peerId)) {
+          clientEntities.set(id, entity);
+        }
+      }
+    }
+    const clientBaseTick = this._clientBaselines.get(peerId);
+    const clientLastKeyframe = this._clientLastKeyframeTick.get(peerId) ?? 0;
+    const needsKeyframe = clientBaseTick === void 0 || currentTick - clientLastKeyframe >= this._keyframeInterval;
+    let baseline;
+    if (!needsKeyframe && clientBaseTick !== void 0) {
+      baseline = this._snapshotBuffer.get(clientBaseTick);
+    }
+    if (needsKeyframe) {
+      this._clientLastKeyframeTick.set(peerId, currentTick);
+    }
+    const packet = this._codec.serializeDelta(
+      currentTick,
+      needsKeyframe ? -1 : clientBaseTick ?? -1,
+      clientEntities,
+      baseline
+    );
+    if (packet) {
+      this._snapshotChannel.send(packet, peerId);
+    }
+  }
+};
+
+// src/core/ClientReceiver.ts
+var ClientReceiver = class {
+  constructor(transport, codec, options) {
+    // Snapshot buffer (ring buffer of last N snapshots)
+    this._buffer = [];
+    // Current interpolated state
+    this._interpolatedState = /* @__PURE__ */ new Map();
+    // Network quality tracking
+    this._lastSnapshotTime = 0;
+    this._networkQuality = "good";
+    this._packetLossCount = 0;
+    this._packetCount = 0;
+    // Entity state: full accumulated state from keyframes + deltas
+    this._fullState = /* @__PURE__ */ new Map();
+    this._transport = transport;
+    this._codec = codec;
+    this._bufferSize = options?.bufferSize ?? 3;
+    this._method = options?.method ?? "hermite";
+    this._extrapolateMs = options?.extrapolateMs ?? 250;
+    this._is2D = options?.is2D ?? false;
+    this._snapshotChannel = transport.createChannel(
+      "carver:snapshots",
+      {
+        reliable: false,
+        ordered: false,
+        maxRetransmits: 0
+      }
+    );
+    this._ackChannel = transport.createChannel("carver:acks", {
+      reliable: true,
+      ordered: true
+    });
+    this._snapshotChannel.onReceive((data) => {
+      this._handleSnapshot(data);
+    });
+  }
+  /** Get the current interpolated entity states */
+  get state() {
+    return this._interpolatedState;
+  }
+  get networkQuality() {
+    return this._networkQuality;
+  }
+  /**
+   * Called every render frame to interpolate between buffered snapshots.
+   * @param renderTime - current render time in ms
+   */
+  interpolate(renderTime) {
+    if (this._buffer.length < 2) {
+      return this._buffer.length > 0 ? this._buffer[this._buffer.length - 1].entities : this._interpolatedState;
+    }
+    const interpDelay = (this._bufferSize - 1) * (1e3 / 20);
+    const targetTime = renderTime - interpDelay;
+    let from = null;
+    let to = null;
+    for (let i = 0; i < this._buffer.length - 1; i++) {
+      if (this._buffer[i].receivedAt <= targetTime && this._buffer[i + 1].receivedAt > targetTime) {
+        from = this._buffer[i];
+        to = this._buffer[i + 1];
+        break;
+      }
+    }
+    if (!from || !to) {
+      const latest = this._buffer[this._buffer.length - 1];
+      const timeSinceLatest = renderTime - latest.receivedAt;
+      if (timeSinceLatest > this._extrapolateMs) {
+        this._updateNetworkQuality("poor");
+        return latest.entities;
+      }
+      if (this._buffer.length >= 2) {
+        from = this._buffer[this._buffer.length - 2];
+        to = latest;
+        this._updateNetworkQuality("degraded");
+      } else {
+        return latest.entities;
+      }
+    } else {
+      this._updateNetworkQuality("good");
+    }
+    const range = to.receivedAt - from.receivedAt;
+    const t = range > 0 ? Math.min(1, Math.max(0, (targetTime - from.receivedAt) / range)) : 1;
+    const result = /* @__PURE__ */ new Map();
+    const allIds = /* @__PURE__ */ new Set([...from.entities.keys(), ...to.entities.keys()]);
+    for (const id of allIds) {
+      const fromEntity = from.entities.get(id);
+      const toEntity = to.entities.get(id);
+      if (toEntity && toEntity.c?.__removed) continue;
+      if (fromEntity && toEntity) {
+        result.set(id, this._interpolateEntity(fromEntity, toEntity, t));
+      } else if (toEntity) {
+        result.set(id, toEntity);
+      }
+    }
+    this._interpolatedState = result;
+    return result;
+  }
+  /** Request a keyframe from the host */
+  requestKeyframe() {
+    this._ackChannel.send("-1");
+  }
+  destroy() {
+    this._snapshotChannel.close();
+    this._ackChannel.close();
+    this._buffer = [];
+    this._interpolatedState.clear();
+    this._fullState.clear();
+  }
+  _handleSnapshot(data) {
+    try {
+      const { tick, baseTick, entities } = this._codec.deserializePacket(data);
+      const now = performance.now();
+      if (baseTick === -1) {
+        this._fullState.clear();
+        for (const entity of entities) {
+          this._fullState.set(entity.id, entity);
+        }
+      } else {
+        for (const entity of entities) {
+          if (entity.c?.__removed) {
+            this._fullState.delete(entity.id);
+          } else {
+            this._fullState.set(entity.id, entity);
+          }
+        }
+      }
+      this._buffer.push({
+        tick,
+        entities: new Map(this._fullState),
+        receivedAt: now
+      });
+      while (this._buffer.length > this._bufferSize * 2) {
+        this._buffer.shift();
+      }
+      this._ackChannel.send(String(tick));
+      this._lastSnapshotTime = now;
+      this._packetCount++;
+    } catch {
+      this._packetLossCount++;
+    }
+  }
+  _interpolateEntity(from, to, t) {
+    if (this._is2D || !("z" in from)) {
+      return this._interpolateEntity2D(
+        from,
+        to,
+        t
+      );
+    }
+    return this._interpolateEntity3D(
+      from,
+      to,
+      t
+    );
+  }
+  _interpolateEntity2D(from, to, t) {
+    if (this._method === "hermite") {
+      return {
+        id: to.id,
+        x: hermite(from.x, from.vx, to.x, to.vx, t),
+        y: hermite(from.y, from.vy, to.y, to.vy, t),
+        a: lerpAngle(from.a, to.a, t),
+        vx: lerp(from.vx, to.vx, t),
+        vy: lerp(from.vy, to.vy, t),
+        va: lerp(from.va, to.va, t),
+        c: interpolateCustom(from.c, to.c, t)
+      };
+    }
+    return {
+      id: to.id,
+      x: lerp(from.x, to.x, t),
+      y: lerp(from.y, to.y, t),
+      a: lerpAngle(from.a, to.a, t),
+      vx: lerp(from.vx, to.vx, t),
+      vy: lerp(from.vy, to.vy, t),
+      va: lerp(from.va, to.va, t),
+      c: interpolateCustom(from.c, to.c, t)
+    };
+  }
+  _interpolateEntity3D(from, to, t) {
+    const [qx, qy, qz, qw] = slerp(
+      from.qx,
+      from.qy,
+      from.qz,
+      from.qw,
+      to.qx,
+      to.qy,
+      to.qz,
+      to.qw,
+      t
+    );
+    if (this._method === "hermite") {
+      return {
+        id: to.id,
+        x: hermite(from.x, from.vx, to.x, to.vx, t),
+        y: hermite(from.y, from.vy, to.y, to.vy, t),
+        z: hermite(from.z, from.vz, to.z, to.vz, t),
+        qx,
+        qy,
+        qz,
+        qw,
+        vx: lerp(from.vx, to.vx, t),
+        vy: lerp(from.vy, to.vy, t),
+        vz: lerp(from.vz, to.vz, t),
+        wx: lerp(from.wx, to.wx, t),
+        wy: lerp(from.wy, to.wy, t),
+        wz: lerp(from.wz, to.wz, t),
+        c: interpolateCustom(from.c, to.c, t)
+      };
+    }
+    return {
+      id: to.id,
+      x: lerp(from.x, to.x, t),
+      y: lerp(from.y, to.y, t),
+      z: lerp(from.z, to.z, t),
+      qx,
+      qy,
+      qz,
+      qw,
+      vx: lerp(from.vx, to.vx, t),
+      vy: lerp(from.vy, to.vy, t),
+      vz: lerp(from.vz, to.vz, t),
+      wx: lerp(from.wx, to.wx, t),
+      wy: lerp(from.wy, to.wy, t),
+      wz: lerp(from.wz, to.wz, t),
+      c: interpolateCustom(from.c, to.c, t)
+    };
+  }
+  _updateNetworkQuality(quality) {
+    this._networkQuality = quality;
+  }
+};
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function lerpAngle(a, b, t) {
+  let diff = b - a;
+  while (diff > Math.PI) diff -= Math.PI * 2;
+  while (diff < -Math.PI) diff += Math.PI * 2;
+  return a + diff * t;
+}
+function hermite(p0, v0, p1, v1, t) {
+  const t2 = t * t;
+  const t3 = t2 * t;
+  return (2 * t3 - 3 * t2 + 1) * p0 + (t3 - 2 * t2 + t) * v0 + (-2 * t3 + 3 * t2) * p1 + (t3 - t2) * v1;
+}
+function slerp(ax, ay, az, aw, bx, by, bz, bw, t) {
+  let dot = ax * bx + ay * by + az * bz + aw * bw;
+  if (dot < 0) {
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+    dot = -dot;
+  }
+  if (dot > 0.9995) {
+    return [lerp(ax, bx, t), lerp(ay, by, t), lerp(az, bz, t), lerp(aw, bw, t)];
+  }
+  const theta = Math.acos(Math.min(1, Math.max(-1, dot)));
+  const sinTheta = Math.sin(theta);
+  const wa = Math.sin((1 - t) * theta) / sinTheta;
+  const wb = Math.sin(t * theta) / sinTheta;
+  return [
+    ax * wa + bx * wb,
+    ay * wa + by * wb,
+    az * wa + bz * wb,
+    aw * wa + bw * wb
+  ];
+}
+function interpolateCustom(from, to, t) {
+  if (!from && !to) return void 0;
+  if (!from) return to;
+  if (!to) return from;
+  const result = {};
+  const allKeys = /* @__PURE__ */ new Set([...Object.keys(from), ...Object.keys(to)]);
+  for (const key of allKeys) {
+    const fromVal = from[key];
+    const toVal = to[key];
+    if (typeof fromVal === "number" && typeof toVal === "number") {
+      result[key] = lerp(fromVal, toVal, t);
+    } else {
+      result[key] = t >= 0.5 ? toVal : fromVal;
+    }
+  }
+  return result;
+}
+
+// src/sync/SnapshotSync.ts
+var SnapshotSync = class {
+  constructor(transport, codec, snapshotBuffer, options) {
+    this._hostAuthority = null;
+    this._clientReceiver = null;
+    this._transport = transport;
+    this._codec = codec;
+    this._snapshotBuffer = snapshotBuffer;
+    if (transport.isHost) {
+      this._hostAuthority = new HostAuthority(
+        transport,
+        codec,
+        snapshotBuffer,
+        {
+          broadcastRate: options?.broadcastRate,
+          keyframeInterval: options?.keyframeInterval
+        }
+      );
+    } else {
+      this._clientReceiver = new ClientReceiver(transport, codec, {
+        bufferSize: options?.bufferSize,
+        method: options?.interpolationMethod,
+        extrapolateMs: options?.extrapolateMs,
+        is2D: options?.is2D
+      });
+    }
+  }
+  get isHost() {
+    return this._hostAuthority !== null;
+  }
+  get hostAuthority() {
+    return this._hostAuthority;
+  }
+  get clientReceiver() {
+    return this._clientReceiver;
+  }
+  /** Host: called every fixed tick to potentially broadcast state */
+  hostTick(tick, entities, delta) {
+    this._hostAuthority?.tick(tick, entities, delta);
+  }
+  /** Client: called every render frame to interpolate */
+  clientInterpolate(renderTime) {
+    return this._clientReceiver?.interpolate(renderTime) ?? /* @__PURE__ */ new Map();
+  }
+  /** Set interest filter on host authority */
+  setInterestFilter(filter) {
+    this._hostAuthority?.setInterestFilter(filter);
+  }
+  /** Handle host migration: switch from client to host mode */
+  promoteToHost(options) {
+    this._clientReceiver?.destroy();
+    this._clientReceiver = null;
+    this._hostAuthority = new HostAuthority(
+      this._transport,
+      this._codec,
+      this._snapshotBuffer,
+      {
+        broadcastRate: options?.broadcastRate,
+        keyframeInterval: options?.keyframeInterval
+      }
+    );
+  }
+  /** Handle host migration: switch from host to client mode */
+  demoteToClient(options) {
+    this._hostAuthority?.destroy();
+    this._hostAuthority = null;
+    this._clientReceiver = new ClientReceiver(
+      this._transport,
+      this._codec,
+      {
+        bufferSize: options?.bufferSize,
+        method: options?.interpolationMethod,
+        extrapolateMs: options?.extrapolateMs,
+        is2D: options?.is2D
+      }
+    );
+  }
+  destroy() {
+    this._hostAuthority?.destroy();
+    this._clientReceiver?.destroy();
+    this._hostAuthority = null;
+    this._clientReceiver = null;
+  }
+};
+
+// src/sync/PredictionSync.ts
+var import_msgpackr = require("msgpackr");
+var DEFAULT_OPTIONS = {
+  maxRewindTicks: 15,
+  errorSmoothingDecay: 0.85,
+  maxErrorPerFrame: 5,
+  snapThreshold: 15,
+  lagCompensation: false
+};
+var PredictionSync = class {
+  constructor(transport, codec, tickKeeper, options) {
+    // Input buffer: ring buffer of recent inputs keyed by tick
+    this._inputBuffer = [];
+    // Per-client last processed input tick (host-side tracking)
+    this._clientLastProcessedTick = /* @__PURE__ */ new Map();
+    // Predicted state (client-side)
+    this._predictedState = /* @__PURE__ */ new Map();
+    // Error correction vectors per entity
+    this._errorCorrections = /* @__PURE__ */ new Map();
+    // Server state (last received authoritative snapshot)
+    this._serverState = /* @__PURE__ */ new Map();
+    this._serverTick = 0;
+    // Physics step callback (provided by developer)
+    this._onPhysicsStep = null;
+    // Own input for current tick
+    this._currentInput = null;
+    this._transport = transport;
+    this._codec = codec;
+    this._tickKeeper = tickKeeper;
+    this._options = { ...DEFAULT_OPTIONS, ...options };
+    this._isHost = transport.isHost;
+    this._inputChannel = transport.createChannel("carver:inputs", {
+      reliable: true,
+      ordered: true
+    });
+    this._stateChannel = transport.createChannel("carver:pred-state", {
+      reliable: false,
+      ordered: false,
+      maxRetransmits: 0
+    });
+    this._ackChannel = transport.createChannel("carver:pred-acks", {
+      reliable: true,
+      ordered: true
+    });
+    if (this._isHost) {
+      this._setupHostListeners();
+    } else {
+      this._setupClientListeners();
+    }
+  }
+  /** Set the physics step callback (required for rollback re-simulation) */
+  setPhysicsStep(cb) {
+    this._onPhysicsStep = cb;
+  }
+  /** Set the current input for this tick (client-side) */
+  setInput(input) {
+    this._currentInput = input;
+  }
+  /**
+   * Called every fixed tick on the client.
+   * Applies input locally (prediction), buffers it, and sends to host.
+   */
+  clientTick(tick) {
+    if (this._isHost) return;
+    if (this._currentInput !== null) {
+      this._inputBuffer.push({ tick, input: this._currentInput });
+      const packet = {
+        t: tick,
+        i: this._currentInput,
+        p: this._transport.peerId
+      };
+      this._inputChannel.send(JSON.stringify(packet));
+      if (this._onPhysicsStep) {
+        const inputs = /* @__PURE__ */ new Map();
+        inputs.set(this._transport.peerId, this._currentInput);
+        this._onPhysicsStep(inputs, tick, false);
+      }
+      this._currentInput = null;
+    }
+    const minTick = tick - this._options.maxRewindTicks * 2;
+    while (this._inputBuffer.length > 0 && this._inputBuffer[0].tick < minTick) {
+      this._inputBuffer.shift();
+    }
+  }
+  /**
+   * Called every fixed tick on the host.
+   * Processes received inputs and broadcasts authoritative state.
+   */
+  hostTick(tick, entities, _delta) {
+    if (!this._isHost) return;
+    const stateArray = Array.from(entities.values());
+    const data = this._codec.serialize(stateArray);
+    for (const peerId of this._transport.peers) {
+      const lastTick = this._clientLastProcessedTick.get(peerId) ?? -1;
+      const packet = {
+        t: tick,
+        s: data,
+        li: lastTick
+      };
+      this._stateChannel.send((0, import_msgpackr.pack)(packet), peerId);
+    }
+  }
+  /**
+   * Called every render frame on the client to apply visual error smoothing.
+   * Returns the corrected entity states.
+   */
+  applyErrorSmoothing(entities) {
+    const result = /* @__PURE__ */ new Map();
+    const decay = this._options.errorSmoothingDecay;
+    for (const [id, entity] of entities) {
+      const correction = this._errorCorrections.get(id);
+      if (!correction) {
+        result.set(id, entity);
+        continue;
+      }
+      const corrected = { ...entity };
+      corrected.x += correction.x;
+      corrected.y += correction.y;
+      if ("z" in corrected) {
+        corrected.z += correction.z;
+      }
+      correction.x *= decay;
+      correction.y *= decay;
+      correction.z *= decay;
+      const mag = Math.abs(correction.x) + Math.abs(correction.y) + Math.abs(correction.z);
+      if (mag < 1e-3) {
+        this._errorCorrections.delete(id);
+      }
+      result.set(id, corrected);
+    }
+    return result;
+  }
+  get predictedState() {
+    return this._predictedState;
+  }
+  get serverTick() {
+    return this._serverTick;
+  }
+  destroy() {
+    this._inputChannel.close();
+    this._stateChannel.close();
+    this._ackChannel.close();
+    this._inputBuffer = [];
+    this._predictedState.clear();
+    this._errorCorrections.clear();
+    this._serverState.clear();
+  }
+  // ── Private: Host-side ──
+  _setupHostListeners() {
+    this._inputChannel.onReceive((rawData, peerId) => {
+      try {
+        const packet = JSON.parse(rawData);
+        if (this._onPhysicsStep) {
+          const inputs = /* @__PURE__ */ new Map();
+          inputs.set(peerId, packet.i);
+          this._onPhysicsStep(inputs, packet.t, false);
+        }
+        const prevTick = this._clientLastProcessedTick.get(peerId) ?? -1;
+        this._clientLastProcessedTick.set(peerId, Math.max(prevTick, packet.t));
+      } catch (err) {
+        if (typeof console !== "undefined") console.debug("[CarverJS] Malformed input packet:", err);
+      }
+    });
+  }
+  // ── Private: Client-side ──
+  _setupClientListeners() {
+    this._stateChannel.onReceive((data) => {
+      try {
+        const packet = (0, import_msgpackr.unpack)(data);
+        const entities = this._codec.deserialize(packet.s);
+        const serverTick = packet.t;
+        const lastInputTick = packet.li;
+        this._serverTick = serverTick;
+        this._tickKeeper.setServerTick(serverTick);
+        this._serverState.clear();
+        for (const entity of entities) {
+          this._serverState.set(entity.id, entity);
+        }
+        this._reconcile(lastInputTick);
+      } catch (err) {
+        if (typeof console !== "undefined") console.debug("[CarverJS] Malformed state packet:", err);
+      }
+    });
+  }
+  _reconcile(lastInputTick) {
+    this._inputBuffer = this._inputBuffer.filter((entry) => entry.tick > lastInputTick);
+    let needsRollback = false;
+    let maxError = 0;
+    for (const [id, serverEntity] of this._serverState) {
+      const predicted = this._predictedState.get(id);
+      if (!predicted) continue;
+      const error = this._computeError(predicted, serverEntity);
+      maxError = Math.max(maxError, error);
+      if (error > this._options.maxErrorPerFrame) {
+        needsRollback = true;
+      }
+    }
+    if (maxError > this._options.snapThreshold) {
+      this._predictedState = new Map(this._serverState);
+      this._errorCorrections.clear();
+      return;
+    }
+    if (needsRollback) {
+      const oldPositions = /* @__PURE__ */ new Map();
+      for (const [id, entity] of this._predictedState) {
+        oldPositions.set(id, {
+          x: entity.x,
+          y: entity.y,
+          z: "z" in entity ? entity.z : 0
+        });
+      }
+      this._predictedState = new Map(this._serverState);
+      if (this._onPhysicsStep) {
+        for (const entry of this._inputBuffer) {
+          const inputs = /* @__PURE__ */ new Map();
+          inputs.set(this._transport.peerId, entry.input);
+          this._onPhysicsStep(inputs, entry.tick, true);
+        }
+      }
+      for (const [id, newEntity] of this._predictedState) {
+        const oldPos = oldPositions.get(id);
+        if (oldPos) {
+          this._errorCorrections.set(id, {
+            x: oldPos.x - newEntity.x,
+            y: oldPos.y - newEntity.y,
+            z: oldPos.z - ("z" in newEntity ? newEntity.z : 0)
+          });
+        }
+      }
+    }
+  }
+  _computeError(predicted, server) {
+    const dx = predicted.x - server.x;
+    const dy = predicted.y - server.y;
+    let dz = 0;
+    if ("z" in predicted && "z" in server) {
+      dz = predicted.z - server.z;
+    }
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventSync,
+  PredictionSync,
+  SnapshotSync
+});
+//# sourceMappingURL=sync.js.map