@carverjs/multiplayer 0.0.1 → 0.0.2

package/dist/sync.js

@@ -22,7 +22,13 @@ var sync_exports = {};
 __export(sync_exports, {
   EventSync: () => EventSync,
   PredictionSync: () => PredictionSync,
-  SnapshotSync: () => SnapshotSync
+  SnapshotSync: () => SnapshotSync,
+  applyRollback: () => applyRollback,
+  quatAngle: () => quatAngle,
+  quatInvert: () => quatInvert,
+  quatMultiply: () => quatMultiply,
+  quatNormalize: () => quatNormalize,
+  quatScaleAngle: () => quatScaleAngle
 });
 module.exports = __toCommonJS(sync_exports);
 
@@ -165,8 +171,9 @@ var HostAuthority = class {
   /**
    * Called every fixed tick by the sync engine.
    * Collects entity states and decides whether to broadcast.
+   * `hostInput` (prediction mode) is embedded in the snapshot packet as `hi`.
    */
-  tick(currentTick, entities, delta) {
+  tick(currentTick, entities, delta, hostInput) {
     this._tick = currentTick;
     this._snapshotBuffer.store(currentTick, new Map(entities));
     this._broadcastAccumulator += delta;
@@ -174,16 +181,16 @@ var HostAuthority = class {
     if (this._broadcastAccumulator < broadcastInterval) return;
     this._broadcastAccumulator -= broadcastInterval;
     for (const peerId of this._transport.peers) {
-      this._broadcastToClient(peerId, currentTick, entities);
+      this._broadcastToClient(peerId, currentTick, entities, hostInput);
     }
   }
   /** Force a keyframe broadcast to all clients (e.g., after host migration) */
-  forceKeyframe(currentTick, entities) {
+  forceKeyframe(currentTick, entities, hostInput) {
     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);
+      this._broadcastToClient(peerId, currentTick, entities, hostInput);
     }
   }
   destroy() {
@@ -192,7 +199,7 @@ var HostAuthority = class {
     this._clientBaselines.clear();
     this._clientLastKeyframeTick.clear();
   }
-  _broadcastToClient(peerId, currentTick, entities) {
+  _broadcastToClient(peerId, currentTick, entities, hostInput) {
     let clientEntities = entities;
     if (this._interestFilter) {
       clientEntities = /* @__PURE__ */ new Map();
@@ -216,7 +223,8 @@ var HostAuthority = class {
       currentTick,
       needsKeyframe ? -1 : clientBaseTick ?? -1,
       clientEntities,
-      baseline
+      baseline,
+      hostInput
     );
     if (packet) {
       this._snapshotChannel.send(packet, peerId);
@@ -238,6 +246,8 @@ var ClientReceiver = class {
     this._packetCount = 0;
     // Entity state: full accumulated state from keyframes + deltas
     this._fullState = /* @__PURE__ */ new Map();
+    // Listeners fired after each snapshot is merged into the full world state
+    this._snapshotListeners = [];
     this._transport = transport;
     this._codec = codec;
     this._bufferSize = options?.bufferSize ?? 3;
@@ -324,16 +334,21 @@ var ClientReceiver = class {
   requestKeyframe() {
     this._ackChannel.send("-1");
   }
+  /** Register a listener fired after each snapshot is merged into the full world state */
+  onSnapshot(cb) {
+    this._snapshotListeners.push(cb);
+  }
   destroy() {
     this._snapshotChannel.close();
     this._ackChannel.close();
     this._buffer = [];
     this._interpolatedState.clear();
     this._fullState.clear();
+    this._snapshotListeners = [];
   }
   _handleSnapshot(data) {
     try {
-      const { tick, baseTick, entities } = this._codec.deserializePacket(data);
+      const { tick, baseTick, entities, hostInput } = this._codec.deserializePacket(data);
       const now = performance.now();
       if (baseTick === -1) {
         this._fullState.clear();
@@ -349,15 +364,19 @@ var ClientReceiver = class {
           }
         }
       }
+      const fullStateClone = new Map(this._fullState);
       this._buffer.push({
         tick,
-        entities: new Map(this._fullState),
+        entities: fullStateClone,
         receivedAt: now
       });
       while (this._buffer.length > this._bufferSize * 2) {
         this._buffer.shift();
       }
       this._ackChannel.send(String(tick));
+      for (const cb of this._snapshotListeners) {
+        cb(tick, fullStateClone, hostInput);
+      }
       this._lastSnapshotTime = now;
       this._packetCount++;
     } catch {
@@ -515,6 +534,8 @@ var SnapshotSync = class {
   constructor(transport, codec, snapshotBuffer, options) {
     this._hostAuthority = null;
     this._clientReceiver = null;
+    // Snapshot listeners survive host migration (forwarder re-attached on demote)
+    this._snapshotListeners = [];
     this._transport = transport;
     this._codec = codec;
     this._snapshotBuffer = snapshotBuffer;
@@ -535,6 +556,7 @@ var SnapshotSync = class {
         extrapolateMs: options?.extrapolateMs,
         is2D: options?.is2D
       });
+      this._attachSnapshotForwarder(this._clientReceiver);
     }
   }
   get isHost() {
@@ -547,8 +569,12 @@ var SnapshotSync = class {
     return this._clientReceiver;
   }
   /** Host: called every fixed tick to potentially broadcast state */
-  hostTick(tick, entities, delta) {
-    this._hostAuthority?.tick(tick, entities, delta);
+  hostTick(tick, entities, delta, hostInput) {
+    this._hostAuthority?.tick(tick, entities, delta, hostInput);
+  }
+  /** Register a listener fired after each merged snapshot (client side). */
+  onSnapshot(cb) {
+    this._snapshotListeners.push(cb);
   }
   /** Client: called every render frame to interpolate */
   clientInterpolate(renderTime) {
@@ -586,260 +612,528 @@ var SnapshotSync = class {
         is2D: options?.is2D
       }
     );
+    this._attachSnapshotForwarder(this._clientReceiver);
   }
   destroy() {
     this._hostAuthority?.destroy();
     this._clientReceiver?.destroy();
     this._hostAuthority = null;
     this._clientReceiver = null;
+    this._snapshotListeners = [];
+  }
+  // ── Private ──
+  /** Forward receiver snapshots to registered listeners (survives host migration). */
+  _attachSnapshotForwarder(receiver) {
+    receiver.onSnapshot((t, e, hi) => {
+      for (const l of this._snapshotListeners) l(t, e, hi);
+    });
+  }
+};
+
+// src/core/InputBuffer.ts
+var InputBuffer = class {
+  constructor(neutralInput, historySize = 120) {
+    /** Local player tick-keyed inputs (ring buffer). */
+    this._local = /* @__PURE__ */ new Map();
+    /** Last-received input per remote peer. */
+    this._remotes = /* @__PURE__ */ new Map();
+    /** Per-peer tick-keyed inputs for accurate rollback re-simulation. */
+    this._peerTicks = /* @__PURE__ */ new Map();
+    this._neutral = { ...neutralInput };
+    this._historySize = historySize;
+  }
+  // ── Local input ──
+  /** Record a snapshot of the local input at the given tick. Evicts the entry exactly historySize back. */
+  storeTick(tick, input) {
+    this._local.set(tick, { ...input });
+    this._local.delete(tick - this._historySize);
+  }
+  /** Return the local input at `tick`, or a neutral copy if out of range. */
+  getTick(tick) {
+    return this._local.get(tick) ?? { ...this._neutral };
+  }
+  /** True if we have a stored local input for this tick (used to avoid spurious justPressed after snap/rejoin). */
+  hasTick(tick) {
+    return this._local.has(tick);
+  }
+  /** Neutral payload with every boolean field forced false (use for justPressed when prev tick is unknown). */
+  getJustPressedZero() {
+    const out = {};
+    for (const key in this._neutral) {
+      const v = this._neutral[key];
+      out[key] = typeof v === "boolean" ? false : v;
+    }
+    return out;
+  }
+  // ── Remote (peer) inputs ──
+  /**
+   * Record a remote peer's input. If `tick` is given (the sender's local tick),
+   * also store it in the per-peer ring buffer for rollback.
+   */
+  setRemote(peerId, input, tick) {
+    this._remotes.set(peerId, input);
+    if (tick !== void 0) {
+      let peerMap = this._peerTicks.get(peerId);
+      if (!peerMap) {
+        peerMap = /* @__PURE__ */ new Map();
+        this._peerTicks.set(peerId, peerMap);
+      }
+      peerMap.set(tick, input);
+      peerMap.delete(tick - this._historySize);
+    }
+  }
+  /** Last-known input for a peer, or a neutral copy if never received. */
+  getRemote(peerId) {
+    return this._remotes.get(peerId) ?? { ...this._neutral };
+  }
+  /** Snapshot of all remote peers' last-known inputs (shallow copy of the map). */
+  allRemotes() {
+    return new Map(this._remotes);
+  }
+  /**
+   * Return a peer's exact input at the given tick (for rollback accuracy),
+   * falling back to their last-known input when history does not reach that far.
+   */
+  getRemoteAtTick(peerId, tick) {
+    return this._peerTicks.get(peerId)?.get(tick) ?? this.getRemote(peerId);
+  }
+  /** Override the last-known input for a peer (does NOT touch tick history). */
+  overrideRemote(peerId, input) {
+    this._remotes.set(peerId, input);
+  }
+  /** Number of currently tracked remote peers. */
+  get peerCount() {
+    return this._remotes.size;
+  }
+  /** Iterate tracked peer IDs. */
+  peerIds() {
+    return this._remotes.keys();
+  }
+  /**
+   * Keep only these peer IDs; remove any other remotes (e.g. after leave/rejoin).
+   * Call when the room's peer list changes so stale peers stop receiving input.
+   */
+  setPeerIds(peerIds) {
+    const set = peerIds instanceof Set ? peerIds : new Set(peerIds);
+    for (const id of this._remotes.keys()) {
+      if (!set.has(id)) {
+        this._remotes.delete(id);
+        this._peerTicks.delete(id);
+      }
+    }
+  }
+  // ── Lifecycle ──
+  /** Clear local history, remote last-known inputs, and per-peer tick history. */
+  clear() {
+    this._local.clear();
+    this._remotes.clear();
+    this._peerTicks.clear();
   }
 };
 
+// src/core/InputUtils.ts
+function computeJustPressed(curr, prev) {
+  const out = {};
+  for (const key in curr) {
+    const c = curr[key];
+    out[key] = typeof c === "boolean" ? c === true && prev[key] !== true : c;
+  }
+  return out;
+}
+
+// src/sync/Rollback.ts
+var IDENTITY_QUAT = { x: 0, y: 0, z: 0, w: 1 };
+function quatMultiply(a, b) {
+  return {
+    x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+    y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+    z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+    w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z
+  };
+}
+function quatInvert(q) {
+  return { x: -q.x, y: -q.y, z: -q.z, w: q.w };
+}
+function quatNormalize(q) {
+  const mag = Math.hypot(q.x, q.y, q.z, q.w);
+  if (mag < 1e-12) return { ...IDENTITY_QUAT };
+  return { x: q.x / mag, y: q.y / mag, z: q.z / mag, w: q.w / mag };
+}
+function quatAngle(q) {
+  return 2 * Math.acos(Math.min(1, Math.abs(q.w)));
+}
+function quatScaleAngle(q, factor) {
+  let n = quatNormalize(q);
+  if (n.w < 0) n = { x: -n.x, y: -n.y, z: -n.z, w: -n.w };
+  const angle = 2 * Math.acos(Math.min(1, n.w));
+  if (angle < 1e-6) return { ...IDENTITY_QUAT };
+  const s = Math.sin(angle / 2);
+  const ax = n.x / s;
+  const ay = n.y / s;
+  const az = n.z / s;
+  const na = angle * factor;
+  const ns = Math.sin(na / 2);
+  return { x: ax * ns, y: ay * ns, z: az * ns, w: Math.cos(na / 2) };
+}
+function applyRollback(params) {
+  const {
+    serverTick,
+    serverState,
+    localTick,
+    localPeerId,
+    inputs,
+    currentErrors,
+    driver,
+    callback,
+    dt,
+    driftTargetTicks,
+    maxRewindTicks,
+    snapThreshold
+  } = params;
+  const preState = driver.captureState();
+  const preMap = /* @__PURE__ */ new Map();
+  for (const [id, s] of preState) {
+    const e = currentErrors.get(id);
+    const ex = e?.x ?? 0;
+    const ey = e?.y ?? 0;
+    if ("z" in s) {
+      const errQ = e ? { x: e.qx, y: e.qy, z: e.qz, w: e.qw } : { ...IDENTITY_QUAT };
+      preMap.set(id, {
+        x: s.x + ex,
+        y: s.y + ey,
+        z: s.z + (e?.z ?? 0),
+        a: 0,
+        q: quatMultiply(errQ, { x: s.qx, y: s.qy, z: s.qz, w: s.qw }),
+        is3D: true
+      });
+    } else {
+      preMap.set(id, {
+        x: s.x + ex,
+        y: s.y + ey,
+        z: 0,
+        a: s.a + (e?.a ?? 0),
+        q: { ...IDENTITY_QUAT },
+        is3D: false
+      });
+    }
+  }
+  driver.applyState(serverState.values());
+  const targetTick = serverTick + driftTargetTicks;
+  const tickDiff = localTick - targetTick;
+  let newLocalTick = localTick;
+  let snapped = false;
+  if (Math.abs(tickDiff) > maxRewindTicks) {
+    newLocalTick = targetTick;
+    snapped = true;
+  } else {
+    for (let i = serverTick + 1; i <= localTick; i++) {
+      if (callback) {
+        const tickInputs = /* @__PURE__ */ new Map();
+        const justPressed = /* @__PURE__ */ new Map();
+        for (const peerId of inputs.peerIds()) {
+          if (peerId === localPeerId) continue;
+          const curr = inputs.getRemoteAtTick(peerId, i);
+          tickInputs.set(peerId, curr);
+          justPressed.set(
+            peerId,
+            computeJustPressed(curr, inputs.getRemoteAtTick(peerId, i - 1))
+          );
+        }
+        const localCurr = inputs.getTick(i);
+        tickInputs.set(localPeerId, localCurr);
+        justPressed.set(
+          localPeerId,
+          computeJustPressed(localCurr, inputs.getTick(i - 1))
+        );
+        callback(tickInputs, justPressed, i, true, dt);
+      }
+      driver.stepWorld?.();
+    }
+  }
+  const postState = driver.captureState();
+  const errors = /* @__PURE__ */ new Map();
+  for (const [id, post] of postState) {
+    const pre = preMap.get(id);
+    if (!pre) continue;
+    const errX = pre.x - post.x;
+    const errY = pre.y - post.y;
+    let errZ = 0;
+    let errA = 0;
+    let q = { ...IDENTITY_QUAT };
+    if ("z" in post) {
+      errZ = pre.z - post.z;
+      let dq = quatNormalize(
+        quatMultiply(
+          pre.q,
+          quatInvert({ x: post.qx, y: post.qy, z: post.qz, w: post.qw })
+        )
+      );
+      if (dq.w < 0) dq = { x: -dq.x, y: -dq.y, z: -dq.z, w: -dq.w };
+      q = dq;
+    } else {
+      const ad = pre.a - post.a;
+      errA = ad - Math.PI * 2 * Math.floor((ad + Math.PI) / (Math.PI * 2));
+    }
+    if (Math.abs(errX) > snapThreshold || Math.abs(errY) > snapThreshold || Math.abs(errZ) > snapThreshold) {
+      errors.set(id, { x: 0, y: 0, z: 0, a: 0, qx: 0, qy: 0, qz: 0, qw: 1 });
+    } else {
+      errors.set(id, {
+        x: errX,
+        y: errY,
+        z: errZ,
+        a: errA,
+        qx: q.x,
+        qy: q.y,
+        qz: q.z,
+        qw: q.w
+      });
+    }
+  }
+  return { newLocalTick, snapped, errors };
+}
+
 // src/sync/PredictionSync.ts
-var import_msgpackr = require("msgpackr");
 var DEFAULT_OPTIONS = {
   maxRewindTicks: 15,
-  errorSmoothingDecay: 0.85,
-  maxErrorPerFrame: 5,
-  snapThreshold: 15,
-  lagCompensation: false
+  snapThreshold: 150,
+  errorDecay: 0.85,
+  maxErrorPerFrame: 0,
+  neutralInput: {},
+  inputHistorySize: 120,
+  driftTargetTicks: 4
 };
 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();
+  constructor(transport, tickKeeper, snapshots, options) {
+    // Local input; persists across ticks until replaced (hold-input semantics)
+    this._currentInput = null;
+    // Newest pending server snapshot awaiting rollback (only the newest survives)
+    this._pending = null;
+    // Per-entity accumulated visual error offsets
+    this._errors = /* @__PURE__ */ new Map();
     this._serverTick = 0;
-    // Physics step callback (provided by developer)
+    this._lastAppliedServerTick = 0;
+    this._worldDriver = null;
     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._inputs = new InputBuffer(
+      this._options.neutralInput,
+      this._options.inputHistorySize
+    );
     this._inputChannel = transport.createChannel("carver:inputs", {
       reliable: true,
       ordered: true
     });
-    this._stateChannel = transport.createChannel("carver:pred-state", {
-      reliable: false,
-      ordered: false,
-      maxRetransmits: 0
+    this._inputChannel.onReceive(
+      (data, peerId) => {
+        try {
+          const packet = typeof data === "string" ? JSON.parse(data) : data;
+          if (typeof packet.t === "number" && packet.i !== null && typeof packet.i === "object") {
+            this._inputs.setRemote(peerId, packet.i, packet.t);
+          }
+        } catch (err) {
+          if (typeof console !== "undefined")
+            console.debug("[CarverJS] Malformed input packet:", err);
+        }
+      }
+    );
+    snapshots.onSnapshot((tick, entities, hostInput) => {
+      if (this._transport.isHost) return;
+      if (tick <= this._lastAppliedServerTick) return;
+      this._serverTick = tick;
+      this._tickKeeper.setServerTick(tick);
+      if (!this._pending || tick > this._pending.t) {
+        this._pending = { t: tick, entities, hostInput };
+      }
     });
-    this._ackChannel = transport.createChannel("carver:pred-acks", {
-      reliable: true,
-      ordered: true
+    transport.onPeerLeave(() => {
+      this._inputs.setPeerIds(this._transport.peers);
     });
-    if (this._isHost) {
-      this._setupHostListeners();
-    } else {
-      this._setupClientListeners();
-    }
   }
-  /** Set the physics step callback (required for rollback re-simulation) */
+  // ── Wiring ──
+  /** Set the game simulation callback (forward sim + rollback resim). */
   setPhysicsStep(cb) {
     this._onPhysicsStep = cb;
   }
-  /** Set the current input for this tick (client-side) */
+  /** Set the world driver used for forward stepping and rollback. */
+  setWorldDriver(driver) {
+    this._worldDriver = driver;
+  }
+  // ── Input ──
+  /** Set the local player's input. PERSISTS across ticks until replaced. */
   setInput(input) {
     this._currentInput = input;
   }
+  /** Local input stored at the given tick (neutral fallback). Used by the host to embed `hi`. */
+  getLocalInput(tick) {
+    return this._inputs.getTick(tick);
+  }
+  // ── Frame lifecycle ──
   /**
-   * Called every fixed tick on the client.
-   * Applies input locally (prediction), buffers it, and sends to host.
+   * Apply the newest pending server snapshot (full-world rollback).
+   * Call once per render frame BEFORE tickKeeper.update().
+   * No-op on host or when nothing is pending.
    */
-  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;
+  beginFrame() {
+    if (this._transport.isHost || !this._pending) return;
+    const pending = this._pending;
+    this._pending = null;
+    this._lastAppliedServerTick = pending.t;
+    if (pending.hostInput !== void 0) {
+      this._inputs.setRemote(
+        this._transport.hostId,
+        pending.hostInput,
+        pending.t
+      );
     }
-    const minTick = tick - this._options.maxRewindTicks * 2;
-    while (this._inputBuffer.length > 0 && this._inputBuffer[0].tick < minTick) {
-      this._inputBuffer.shift();
+    if (!this._worldDriver) return;
+    const result = applyRollback({
+      serverTick: pending.t,
+      serverState: pending.entities,
+      localTick: this._tickKeeper.tick,
+      localPeerId: this._transport.peerId,
+      inputs: this._inputs,
+      currentErrors: this._errors,
+      driver: this._worldDriver,
+      callback: this._onPhysicsStep,
+      dt: this._tickKeeper.tickDelta,
+      driftTargetTicks: this._options.driftTargetTicks,
+      maxRewindTicks: this._options.maxRewindTicks,
+      snapThreshold: this._options.snapThreshold
+    });
+    this._errors = result.errors;
+    if (result.newLocalTick !== this._tickKeeper.tick) {
+      this._tickKeeper.snapTick(result.newLocalTick);
     }
   }
   /**
-   * Called every fixed tick on the host.
-   * Processes received inputs and broadcasts authoritative state.
+   * Run one forward fixed tick (host AND client): store + broadcast input,
+   * build per-tick input maps, invoke the callback, then step the world.
    */
-  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);
+  tick(tick) {
+    const localInput = this._currentInput ?? { ...this._options.neutralInput };
+    this._inputs.storeTick(tick, localInput);
+    this._inputChannel.send({
+      t: tick,
+      i: localInput,
+      p: this._transport.peerId
+    });
+    const prevTick = tick - 1;
+    const tickInputs = this._inputs.allRemotes();
+    tickInputs.delete(this._transport.peerId);
+    const justPressed = /* @__PURE__ */ new Map();
+    for (const [peerId, inp] of tickInputs) {
+      justPressed.set(
+        peerId,
+        computeJustPressed(inp, this._inputs.getRemoteAtTick(peerId, prevTick))
+      );
     }
+    tickInputs.set(this._transport.peerId, localInput);
+    justPressed.set(
+      this._transport.peerId,
+      this._inputs.hasTick(prevTick) ? computeJustPressed(localInput, this._inputs.getTick(prevTick)) : this._inputs.getJustPressedZero()
+      // suppress spurious edges after snap/rejoin
+    );
+    if (this._onPhysicsStep) {
+      this._onPhysicsStep(
+        tickInputs,
+        justPressed,
+        tick,
+        false,
+        this._tickKeeper.tickDelta
+      );
+    }
+    this._worldDriver?.stepWorld?.();
   }
   /**
-   * Called every render frame on the client to apply visual error smoothing.
-   * Returns the corrected entity states.
+   * Decay stored error offsets and return the portion to ADD to rendered
+   * transforms this frame. Call exactly once per render frame.
    */
-  applyErrorSmoothing(entities) {
+  getRenderErrorOffsets() {
     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 decay = this._options.errorDecay;
+    const maxErr = this._options.maxErrorPerFrame;
+    for (const [id, e] of this._errors) {
+      e.x *= decay;
+      e.y *= decay;
+      e.z *= decay;
+      e.a *= decay;
+      let q = quatScaleAngle({ x: e.qx, y: e.qy, z: e.qz, w: e.qw }, decay);
+      if (Math.abs(e.x) < 0.1) e.x = 0;
+      if (Math.abs(e.y) < 0.1) e.y = 0;
+      if (Math.abs(e.z) < 0.1) e.z = 0;
+      if (Math.abs(e.a) < 1e-3) e.a = 0;
+      if (quatAngle(q) < 1e-3) q = { x: 0, y: 0, z: 0, w: 1 };
+      e.qx = q.x;
+      e.qy = q.y;
+      e.qz = q.z;
+      e.qw = q.w;
+      let ax = e.x;
+      let ay = e.y;
+      let az = e.z;
+      if (maxErr > 0) {
+        const mag = Math.hypot(e.x, e.y, e.z);
+        if (mag > maxErr) {
+          const s = maxErr / mag;
+          ax = e.x * s;
+          ay = e.y * s;
+          az = e.z * s;
+          e.x -= ax;
+          e.y -= ay;
+          e.z -= az;
+        } else {
+          e.x = 0;
+          e.y = 0;
+          e.z = 0;
+        }
       }
-      const corrected = { ...entity };
-      corrected.x += correction.x;
-      corrected.y += correction.y;
-      if ("z" in corrected) {
-        corrected.z += correction.z;
+      const quatIsIdentity = e.qx === 0 && e.qy === 0 && e.qz === 0 && e.qw === 1;
+      if (ax !== 0 || ay !== 0 || az !== 0 || e.a !== 0 || !quatIsIdentity) {
+        result.set(id, {
+          x: ax,
+          y: ay,
+          z: az,
+          a: e.a,
+          qx: e.qx,
+          qy: e.qy,
+          qz: e.qz,
+          qw: e.qw
+        });
       }
-      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);
+      if (e.x === 0 && e.y === 0 && e.z === 0 && e.a === 0 && quatIsIdentity) {
+        this._errors.delete(id);
       }
-      result.set(id, corrected);
     }
     return result;
   }
-  get predictedState() {
-    return this._predictedState;
-  }
+  // ── State ──
+  /** Tick of the newest RECEIVED snapshot. */
   get serverTick() {
     return this._serverTick;
   }
+  /** Tick of the newest APPLIED (rolled-back) snapshot, 0 initially. */
+  get lastAppliedServerTick() {
+    return this._lastAppliedServerTick;
+  }
   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);
+    this._inputs.clear();
+    this._errors.clear();
+    this._pending = null;
+    this._currentInput = null;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   EventSync,
   PredictionSync,
-  SnapshotSync
+  SnapshotSync,
+  applyRollback,
+  quatAngle,
+  quatInvert,
+  quatMultiply,
+  quatNormalize,
+  quatScaleAngle
 });
 //# sourceMappingURL=sync.js.map