@carverjs/multiplayer 0.0.1 → 0.0.3

package/dist/index.js

@@ -32,11 +32,13 @@ var src_exports = {};
 __export(src_exports, {
   DebugOverlay: () => DebugOverlay,
   FirebaseStrategy: () => FirebaseStrategy,
+  InputBuffer: () => InputBuffer,
   InterestManager: () => InterestManager,
   MqttStrategy: () => MqttStrategy,
   MultiplayerBridge: () => MultiplayerBridge,
   MultiplayerProvider: () => MultiplayerProvider,
   NetworkSimulator: () => NetworkSimulator,
+  computeJustPressed: () => computeJustPressed,
   useHost: () => useHost,
   useLobby: () => useLobby,
   useMultiplayer: () => useMultiplayer,
@@ -128,6 +130,7 @@ var MqttStrategy = class {
     this._peerExpiryTimer = null;
     this._lobbySubscribed = false;
     this._destroyed = false;
+    this._lastAnnouncement = null;
     this.selfId = generatePeerId();
     this._appId = appId;
     this._config = config;
@@ -193,9 +196,19 @@ var MqttStrategy = class {
       removeFromArray(this._onLobby, cb);
     };
   }
+  updateRoomOccupancy(roomId, playerCount, state) {
+    const ann = this._lastAnnouncement;
+    if (!ann || ann.roomId !== roomId || !this._client) return;
+    ann.playerCount = playerCount;
+    if (state) ann.state = state;
+    ann.lastSeen = Date.now();
+    const topic = mqttTopics(this._appId, roomId, "").roomLobbyEntry;
+    this._client.publish(topic, JSON.stringify(ann), { retain: true, qos: 1 });
+  }
   announceRoom(announcement) {
     if (!this._client) return;
     const topic = mqttTopics(this._appId, announcement.roomId, "").roomLobbyEntry;
+    this._lastAnnouncement = announcement;
     announcement.lastSeen = Date.now();
     this._client.publish(topic, JSON.stringify(announcement), { retain: true, qos: 1 });
     if (this._lobbyAnnounceTimer) clearInterval(this._lobbyAnnounceTimer);
@@ -393,6 +406,8 @@ var FirebaseStrategy = class {
     // State
     this._knownPeers = /* @__PURE__ */ new Set();
     this._lobbyAnnounceTimer = null;
+    this._lastAnnouncement = null;
+    this._lobbyWired = false;
     this._destroyed = false;
     this.selfId = generatePeerId();
     this._appId = appId;
@@ -408,7 +423,7 @@ var FirebaseStrategy = class {
     this._joinGeneration++;
     this._roomId = roomId;
     this._peerMeta = peerMeta;
-    const { ref, set, onChildAdded, onChildRemoved, onDisconnect, remove } = this._fb;
+    const { ref, set, onChildAdded, onChildRemoved, onDisconnect, onValue, remove } = this._fb;
     const paths = firebasePaths(this._appId, roomId, this.selfId);
     await remove(ref(this._db, paths.peerSignalInbox)).catch(() => {
     });
@@ -419,6 +434,18 @@ var FirebaseStrategy = class {
       ts: Date.now()
     });
     onDisconnect(presenceRef).remove();
+    const generation = this._joinGeneration;
+    const connectedRef = ref(this._db, ".info/connected");
+    const connectedUnsub = onValue(connectedRef, (snap) => {
+      if (snap.val() !== true) return;
+      if (this._destroyed || this._joinGeneration !== generation || this._roomId !== roomId) return;
+      onDisconnect(presenceRef).remove().then(() => {
+        if (this._destroyed || this._joinGeneration !== generation || this._roomId !== roomId) return;
+        return set(presenceRef, { peerId: this.selfId, meta: peerMeta, ts: Date.now() });
+      }).catch(() => {
+      });
+    });
+    this._listeners.push(() => connectedUnsub());
     const peersRef = ref(this._db, paths.peers);
     const addedUnsub = onChildAdded(peersRef, (snapshot) => {
       const data = snapshot.val();
@@ -481,6 +508,12 @@ var FirebaseStrategy = class {
   }
   subscribeToLobby(cb) {
     this._onLobby.push(cb);
+    if (this._lobbyWired) {
+      return () => {
+        removeFromArray(this._onLobby, cb);
+      };
+    }
+    this._lobbyWired = true;
     this._ensureInit().then(() => {
       if (!this._db || !this._fb || this._destroyed) return;
       const { ref, onValue } = this._fb;
@@ -508,14 +541,25 @@ var FirebaseStrategy = class {
     if (!this._db || !this._fb) return;
     const { ref, set } = this._fb;
     const paths = firebasePaths(this._appId, announcement.roomId, "");
+    this._lastAnnouncement = announcement;
     announcement.lastSeen = Date.now();
-    set(ref(this._db, paths.roomLobbyEntry), announcement);
+    set(ref(this._db, paths.roomLobbyEntry), sanitizeForFirebase(announcement));
     if (this._lobbyAnnounceTimer) clearInterval(this._lobbyAnnounceTimer);
     this._lobbyAnnounceTimer = setInterval(() => {
       announcement.lastSeen = Date.now();
-      set(ref(this._db, paths.roomLobbyEntry), announcement);
+      set(ref(this._db, paths.roomLobbyEntry), sanitizeForFirebase(announcement));
     }, ROOM_ANNOUNCE_INTERVAL_MS);
   }
+  updateRoomOccupancy(roomId, playerCount, state) {
+    const ann = this._lastAnnouncement;
+    if (!ann || ann.roomId !== roomId || !this._db || !this._fb) return;
+    ann.playerCount = playerCount;
+    if (state) ann.state = state;
+    ann.lastSeen = Date.now();
+    const { ref, set } = this._fb;
+    const paths = firebasePaths(this._appId, roomId, "");
+    set(ref(this._db, paths.roomLobbyEntry), sanitizeForFirebase(ann));
+  }
   removeRoomAnnouncement(roomId) {
     if (!this._db || !this._fb) return;
     const { ref, remove } = this._fb;
@@ -618,6 +662,7 @@ function sanitizeForFirebase(obj) {
   if (typeof obj === "object" && obj !== null) {
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
+      if (value === void 0) continue;
       result[key] = value === null ? "__null__" : sanitizeForFirebase(value);
     }
     return result;
@@ -665,6 +710,11 @@ var _TickKeeper = class _TickKeeper {
     this._serverTick = serverTick;
     this._updateDriftCorrection();
   }
+  /** Hard-set the local tick (prediction rollback snap). Does not touch the accumulator. */
+  snapTick(tick) {
+    this._tick = tick;
+    this._updateDriftCorrection();
+  }
   /**
    * Accumulate time and return the number of fixed ticks to process.
    * Call this once per render frame with the raw frame delta.
@@ -789,15 +839,16 @@ var Codec = class {
     }
     return changed.length > 0 ? changed : null;
   }
-  /** Serialize a delta snapshot packet */
-  serializeDelta(tick, baseTick, current, baseline) {
+  /** Serialize a delta snapshot packet (optionally embedding the host's own input as `hi`) */
+  serializeDelta(tick, baseTick, current, baseline, hostInput) {
     const delta = this.computeDelta(current, baseline);
     if (!delta) return null;
     const packet = {
       t: tick,
       b: baseline ? baseTick : -1,
       // -1 = keyframe
-      s: this.serialize(delta)
+      s: this.serialize(delta),
+      ...hostInput !== void 0 ? { hi: hostInput } : {}
     };
     return (0, import_msgpackr.pack)(packet);
   }
@@ -807,7 +858,8 @@ var Codec = class {
     return {
       tick: packet.t,
       baseTick: packet.b,
-      entities: this.deserialize(packet.s)
+      entities: this.deserialize(packet.s),
+      hostInput: packet.hi
     };
   }
   _hasChanged(current, prev) {
@@ -1119,6 +1171,7 @@ function MultiplayerProvider({
 }) {
   const managerRef = (0, import_react2.useRef)(null);
   const strategyRef = (0, import_react2.useRef)(null);
+  const destroyTimerRef = (0, import_react2.useRef)(null);
   if (!managerRef.current) {
     managerRef.current = new NetworkManager();
   }
@@ -1126,11 +1179,18 @@ function MultiplayerProvider({
     strategyRef.current = createStrategy(appId, strategyConfig);
   }
   (0, import_react2.useEffect)(() => {
+    if (destroyTimerRef.current) {
+      clearTimeout(destroyTimerRef.current);
+      destroyTimerRef.current = null;
+    }
     return () => {
-      strategyRef.current?.destroy();
-      strategyRef.current = null;
-      managerRef.current?.destroy();
-      managerRef.current = null;
+      destroyTimerRef.current = setTimeout(() => {
+        destroyTimerRef.current = null;
+        strategyRef.current?.destroy();
+        strategyRef.current = null;
+        managerRef.current?.destroy();
+        managerRef.current = null;
+      }, 0);
     };
   }, []);
   const value = {
@@ -1220,8 +1280,8 @@ var PeerConnection = class {
       this._events.onStateChange(newState);
     }
   }
-  async createOffer() {
-    const offer = await this._connection.createOffer();
+  async createOffer(options) {
+    const offer = await this._connection.createOffer(options);
     await this._connection.setLocalDescription(offer);
     return offer;
   }
@@ -1297,8 +1357,17 @@ var PeerConnection = class {
 
 // src/transport/webrtc/WebRTCTransport.ts
 var ROOM_CONTROL_CHANNEL = "carver:room-control";
-function electHost(peerIds) {
-  return [...peerIds].sort()[0];
+function electHost(peerIds, rankOf) {
+  let best = peerIds[0];
+  let bestRank = rankOf(best);
+  for (const id of peerIds) {
+    const rank = rankOf(id);
+    if (rank < bestRank || rank === bestRank && id < best) {
+      best = id;
+      bestRank = rank;
+    }
+  }
+  return best;
 }
 var WebRTCTransport = class {
   /**
@@ -1326,6 +1395,11 @@ var WebRTCTransport = class {
     this._playerMap = /* @__PURE__ */ new Map();
     this._initialPeers = [];
     this._strategyUnsubs = [];
+    // ── Private: WebRTC peer management ──
+    /** Grace timers for transient ICE 'disconnected' states */
+    this._disconnectTimers = /* @__PURE__ */ new Map();
+    /** Sends queued while a data channel is not yet open: key = peerIdchannel */
+    this._pendingSends = /* @__PURE__ */ new Map();
     this._strategy = strategy;
     this._peerId = strategy.selfId;
     this._iceConfig = buildICEConfig({ iceServers, iceTransportPolicy });
@@ -1421,10 +1495,7 @@ var WebRTCTransport = class {
     );
     this._strategyUnsubs.push(
       this._strategy.onPeerLeft((peerId) => {
-        this._removePeer(peerId);
-        this._playerMap.delete(peerId);
-        this._electAndSetHost();
-        for (const cb of this._callbacks.onPeerLeave) cb(peerId);
+        this._onStrategyPeerLeft(peerId);
       })
     );
     this._strategyUnsubs.push(
@@ -1537,16 +1608,17 @@ var WebRTCTransport = class {
   _onStrategyPeerDiscovered(peerId, meta) {
     this._connectToPeer(peerId);
     this._peerSet.add(peerId);
+    const existing = this._playerMap.get(peerId);
     const player = {
       peerId,
-      displayName: meta.displayName ?? `Player-${peerId.slice(0, 4)}`,
+      displayName: meta.displayName ?? existing?.displayName ?? `Player-${peerId.slice(0, 4)}`,
       isHost: false,
       isSelf: false,
-      isReady: false,
+      isReady: existing?.isReady ?? false,
       isConnected: true,
       metadata: meta,
-      latencyMs: 0,
-      joinedAt: Date.now()
+      latencyMs: existing?.latencyMs ?? 0,
+      joinedAt: existing?.joinedAt ?? Date.now()
     };
     this._playerMap.set(peerId, player);
     this._electAndSetHost();
@@ -1626,6 +1698,7 @@ var WebRTCTransport = class {
       case "request-room-state": {
         if (!this._isHost || !this._room) break;
         this._room.state = msg.state;
+        this._strategy.updateRoomOccupancy?.(this._room.id, this._room.playerCount, this._room.state);
         this._broadcastControlMessage({ type: "room-updated", room: this._room });
         break;
       }
@@ -1670,9 +1743,20 @@ var WebRTCTransport = class {
     this._handleControlMessage(msg, this._peerId);
   }
   // ── Private: Host election ──
+  /**
+   * Host-election rank for a peer: lower wins. Reads `metadata.hostPriority`
+   * (advertised via player metadata / signaling presence, so every peer sees
+   * the same value). Peers that don't advertise a priority rank last, which
+   * preserves the legacy lowest-peerId election among them.
+   */
+  _hostRank(peerId) {
+    const meta = this._playerMap.get(peerId)?.metadata;
+    const priority = meta?.hostPriority;
+    return typeof priority === "number" && Number.isFinite(priority) ? priority : Number.POSITIVE_INFINITY;
+  }
   _electAndSetHost() {
     const allIds = [this._peerId, ...this._peerSet];
-    const newHostId = electHost(allIds);
+    const newHostId = electHost(allIds, (id) => this._hostRank(id));
     const changed = newHostId !== this._hostId;
     this._hostId = newHostId;
     this._isHost = newHostId === this._peerId;
@@ -1682,16 +1766,23 @@ var WebRTCTransport = class {
     if (this._room) {
       this._room.hostId = newHostId;
       this._room.playerCount = this._playerMap.size;
+      this._strategy.updateRoomOccupancy?.(this._room.id, this._room.playerCount, this._room.state);
     }
     if (changed) {
       for (const cb of this._callbacks.onHostChanged) cb(newHostId);
     }
   }
-  // ── Private: WebRTC peer management ──
   _connectToPeer(peerId) {
     if (this._peers.has(peerId)) return;
     const peer = new PeerConnection(peerId, this._iceConfig, {
       onStateChange: (state) => {
+        if (state === "connected") {
+          const timer = this._disconnectTimers.get(peerId);
+          if (timer) {
+            clearTimeout(timer);
+            this._disconnectTimers.delete(peerId);
+          }
+        }
         if (state === "connected" && this._isHost && this._room) {
           const syncMsg = {
             type: "sync-state",
@@ -1703,10 +1794,7 @@ var WebRTCTransport = class {
           }, 100);
         }
         if (state === "failed" || state === "disconnected") {
-          this._removePeer(peerId);
-          this._playerMap.delete(peerId);
-          this._electAndSetHost();
-          for (const cb of this._callbacks.onPeerLeave) cb(peerId);
+          this._handleConnectionDrop(peerId, state);
         }
       },
       onDataChannel: (channel) => {
@@ -1766,21 +1854,90 @@ var WebRTCTransport = class {
       } catch {
       }
     };
+    dataChannel.onopen = () => this._flushPendingSends(peerId, channelName);
+    if (dataChannel.readyState === "open") this._flushPendingSends(peerId, channelName);
   }
   _sendOnChannel(channelName, data, target) {
     const serialized = typeof data === "object" && data !== null && !(data instanceof ArrayBuffer) && !(data instanceof Uint8Array) ? JSON.stringify(data) : data;
     const targets = target ? Array.isArray(target) ? target : [target] : Array.from(this._peers.keys());
     for (const pid of targets) {
       const peer = this._peers.get(pid);
-      const ch = peer?.getDataChannel(channelName);
+      if (!peer) continue;
+      const ch = peer.getDataChannel(channelName);
       if (ch?.readyState === "open") {
         try {
           ch.send(serialized);
         } catch {
         }
+      } else {
+        const key = pid + "\0" + channelName;
+        const q = this._pendingSends.get(key) ?? [];
+        if (q.length < 200) q.push(serialized);
+        this._pendingSends.set(key, q);
+      }
+    }
+  }
+  _flushPendingSends(peerId, channelName) {
+    const key = peerId + "\0" + channelName;
+    const q = this._pendingSends.get(key);
+    if (!q || q.length === 0) return;
+    const ch = this._peers.get(peerId)?.getDataChannel(channelName);
+    if (ch?.readyState !== "open") return;
+    this._pendingSends.delete(key);
+    for (const msg of q) {
+      try {
+        ch.send(msg);
+      } catch {
+        break;
       }
     }
   }
+  /**
+   * Signaling presence reports a peer left. This is NOT authoritative for an
+   * established session: a transient signaling (Firebase/MQTT) disconnect can
+   * remove a peer's presence while the direct WebRTC link is perfectly healthy.
+   * Keep the peer if its connection is still 'connected'; genuine departures
+   * are also surfaced by the WebRTC connection-state machine
+   * (failed/disconnected -> _handleConnectionDrop), which tears the peer down.
+   */
+  _onStrategyPeerLeft(peerId) {
+    const peer = this._peers.get(peerId);
+    if (peer && peer.state === "connected") return;
+    this._teardownPeer(peerId);
+  }
+  /**
+   * Self-heal a dropped P2P link instead of tearing it down immediately. ICE
+   * 'disconnected' is frequently transient and 'failed' can often recover via
+   * an ICE restart. The deterministic initiator (lower peerId) renegotiates by
+   * sending a fresh offer with iceRestart; the answerer replies through the
+   * existing _handleSignal('offer') path. A grace timer is the fallback: tear
+   * the peer down only if it doesn't return to 'connected'. Recovery to
+   * 'connected' cancels the timer (see onStateChange in _connectToPeer).
+   */
+  _handleConnectionDrop(peerId, state) {
+    if (this._disconnectTimers.has(peerId)) return;
+    if (this._peerId < peerId) {
+      const peer = this._peers.get(peerId);
+      peer?.createOffer({ iceRestart: true }).then((offer) => {
+        if (this._peers.get(peerId) === peer) {
+          this._strategy.signal(peerId, { type: "offer", sdp: offer });
+        }
+      }).catch(() => {
+      });
+    }
+    const graceMs = state === "failed" ? 8e3 : 5e3;
+    this._disconnectTimers.set(peerId, setTimeout(() => {
+      this._disconnectTimers.delete(peerId);
+      const p = this._peers.get(peerId);
+      if (p && p.state !== "connected") this._teardownPeer(peerId);
+    }, graceMs));
+  }
+  _teardownPeer(peerId) {
+    this._removePeer(peerId);
+    this._playerMap.delete(peerId);
+    this._electAndSetHost();
+    for (const cb of this._callbacks.onPeerLeave) cb(peerId);
+  }
   _removePeer(peerId) {
     const peer = this._peers.get(peerId);
     if (peer) {
@@ -1789,6 +1946,14 @@ var WebRTCTransport = class {
     }
     this._peerSet.delete(peerId);
     this._rateLimitCounters.delete(peerId);
+    const timer = this._disconnectTimers.get(peerId);
+    if (timer) {
+      clearTimeout(timer);
+      this._disconnectTimers.delete(peerId);
+    }
+    for (const key of [...this._pendingSends.keys()]) {
+      if (key.startsWith(peerId + "\0")) this._pendingSends.delete(key);
+    }
   }
   _checkRateLimit(peerId) {
     const now = Date.now();
@@ -1970,7 +2135,7 @@ function announcementToRoom(ann) {
     isPrivate: ann.isPrivate,
     metadata: ann.metadata,
     createdAt: ann.createdAt,
-    state: "lobby"
+    state: ann.state ?? "lobby"
   };
 }
 function useLobby(options) {
@@ -2016,7 +2181,7 @@ function useLobby(options) {
       hostId: strategy.selfId,
       playerCount: 0,
       maxPlayers: config.maxPlayers ?? 8,
-      gameMode: config.metadata?.gameMode,
+      gameMode: config.gameMode ?? config.metadata?.gameMode,
       isPrivate: config.isPrivate ?? false,
       metadata: config.metadata ?? {},
       createdAt: Date.now(),
@@ -2246,8 +2411,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;
@@ -2255,16 +2421,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() {
@@ -2273,7 +2439,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();
@@ -2297,7 +2463,8 @@ var HostAuthority = class {
       currentTick,
       needsKeyframe ? -1 : clientBaseTick ?? -1,
       clientEntities,
-      baseline
+      baseline,
+      hostInput
     );
     if (packet) {
       this._snapshotChannel.send(packet, peerId);
@@ -2319,6 +2486,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;
@@ -2405,16 +2574,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();
@@ -2430,15 +2604,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 {
@@ -2596,6 +2774,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;
@@ -2616,6 +2796,7 @@ var SnapshotSync = class {
         extrapolateMs: options?.extrapolateMs,
         is2D: options?.is2D
       });
+      this._attachSnapshotForwarder(this._clientReceiver);
     }
   }
   get isHost() {
@@ -2628,8 +2809,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) {
@@ -2667,254 +2852,516 @@ 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_msgpackr2 = 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_msgpackr2.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_msgpackr2.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;
   }
 };
 
@@ -3110,6 +3557,34 @@ function applyState3D(ref, state) {
     }
   }
 }
+function applyStateHard2D(ref, state) {
+  applyState2D(ref, state);
+  if (ref.rigidBody) {
+    try {
+      if (typeof ref.rigidBody.setLinvel === "function") {
+        ref.rigidBody.setLinvel({ x: state.vx, y: state.vy }, true);
+      }
+      if (typeof ref.rigidBody.setAngvel === "function") {
+        ref.rigidBody.setAngvel(state.va, true);
+      }
+    } catch {
+    }
+  }
+}
+function applyStateHard3D(ref, state) {
+  applyState3D(ref, state);
+  if (ref.rigidBody) {
+    try {
+      if (typeof ref.rigidBody.setLinvel === "function") {
+        ref.rigidBody.setLinvel({ x: state.vx, y: state.vy, z: state.vz }, true);
+      }
+      if (typeof ref.rigidBody.setAngvel === "function") {
+        ref.rigidBody.setAngvel({ x: state.wx, y: state.wy, z: state.wz }, true);
+      }
+    } catch {
+    }
+  }
+}
 function applyEntityState(ref, state, is2D) {
   if (is2D) {
     applyState2D(ref, state);
@@ -3125,6 +3600,10 @@ function applyStatesToActors(states, registry, is2D) {
     applyEntityState(ref, state, is2D);
   }
 }
+var IDENTITY_QUAT2 = { x: 0, y: 0, z: 0, w: 1 };
+function isIdentityQuat(q) {
+  return q.x === 0 && q.y === 0 && q.z === 0 && q.w === 1;
+}
 function useMultiplayer(options = {}) {
   const { networkManager } = useMultiplayerContext();
   const mode = options.mode ?? networkManager.syncMode;
@@ -3140,6 +3619,7 @@ function useMultiplayer(options = {}) {
   const [drift, setDrift] = (0, import_react8.useState)(0);
   const actorRegistry = (0, import_react8.useRef)((0, import_systems.getActorRegistry)());
   const wasHostRef = (0, import_react8.useRef)(null);
+  const appliedErrorsRef = (0, import_react8.useRef)(/* @__PURE__ */ new Map());
   const buildSnapshotOpts = (0, import_react8.useCallback)(() => {
     return {
       broadcastRate: options.broadcastRate,
@@ -3156,6 +3636,36 @@ function useMultiplayer(options = {}) {
     options.interpolation?.method,
     options.interpolation?.extrapolateMs
   ]);
+  const undoAppliedErrorOffsets = (0, import_react8.useCallback)(() => {
+    const registry = actorRegistry.current;
+    for (const [id, e] of appliedErrorsRef.current) {
+      const ref = registry.get(id);
+      if (!ref) {
+        appliedErrorsRef.current.delete(id);
+        continue;
+      }
+      const pos = ref.object3D.position;
+      const untouched = Math.abs(pos.x - e.px) < 1e-9 && Math.abs(pos.y - e.py) < 1e-9 && Math.abs(pos.z - e.pz) < 1e-9;
+      if (untouched) {
+        pos.x -= e.x;
+        pos.y -= e.y;
+        pos.z -= e.z;
+        if (e.a !== 0) {
+          ref.object3D.rotation.z -= e.a;
+        }
+        if (!isIdentityQuat(e.q)) {
+          const inv = quatInvert(e.q);
+          const cur = ref.object3D.quaternion;
+          const r = quatMultiply(inv, { x: cur.x, y: cur.y, z: cur.z, w: cur.w });
+          cur.set(r.x, r.y, r.z, r.w);
+        }
+      }
+    }
+    appliedErrorsRef.current.clear();
+  }, []);
+  const setInput = (0, import_react8.useCallback)((input) => {
+    predictionSyncRef.current?.setInput(input);
+  }, []);
   (0, import_react8.useEffect)(() => {
     const transport = networkManager.transport;
     if (!transport) return;
@@ -3184,15 +3694,30 @@ function useMultiplayer(options = {}) {
       );
     }
     if (mode === "prediction") {
+      const driver = {
+        captureState: () => buildEntityMap(actorRegistry.current.getNetworked(), is2DRef.current ?? true),
+        applyState: (entities) => {
+          const is2D = is2DRef.current ?? true;
+          for (const state of entities) {
+            if (state.c && state.c.__removed) continue;
+            const ref = actorRegistry.current.get(state.id);
+            if (!ref) continue;
+            if (is2D) applyStateHard2D(ref, state);
+            else applyStateHard3D(ref, state);
+          }
+        },
+        ...options.stepWorld ? { stepWorld: options.stepWorld } : {}
+      };
       predictionSyncRef.current = new PredictionSync(
         transport,
-        networkManager.codec,
         networkManager.tickKeeper,
+        snapshotSyncRef.current,
         options.prediction
       );
       if (options.onPhysicsStep) {
         predictionSyncRef.current.setPhysicsStep(options.onPhysicsStep);
       }
+      predictionSyncRef.current.setWorldDriver(driver);
     }
     wasHostRef.current = networkManager.isHost;
     setIsActive(true);
@@ -3221,9 +3746,10 @@ function useMultiplayer(options = {}) {
       snapshotSyncRef.current = null;
       predictionSyncRef.current = null;
       networkSimulatorRef.current = null;
+      appliedErrorsRef.current.clear();
       setIsActive(false);
     };
-  }, [networkManager, mode, buildSnapshotOpts, options.prediction, options.onPhysicsStep, options.debug]);
+  }, [networkManager, mode, buildSnapshotOpts, options.prediction, options.onPhysicsStep, options.stepWorld, options.debug]);
   (0, import_react8.useEffect)(() => {
     const unsub = networkManager.onConnectionStateChange(() => {
       setNetworkQuality(networkManager.networkQuality);
@@ -3243,33 +3769,67 @@ function useMultiplayer(options = {}) {
     }
     const is2D = is2DRef.current ?? true;
     if (mode === "events") return;
+    if (mode === "prediction" && predictionSyncRef.current) {
+      undoAppliedErrorOffsets();
+      predictionSyncRef.current.beginFrame();
+    }
     const ticksThisFrame = tickKeeper.update(delta);
     for (let i = 0; i < ticksThisFrame; i++) {
       const currentTick = tickKeeper.tick - (ticksThisFrame - 1 - i);
-      if (isHost) {
+      if (mode === "prediction" && predictionSyncRef.current) {
+        predictionSyncRef.current.tick(currentTick);
+        if (isHost) {
+          const entities = buildEntityMap(actorRegistry.current.getNetworked(), is2D);
+          snapshotSyncRef.current?.hostTick(
+            currentTick,
+            entities,
+            tickKeeper.tickDelta,
+            predictionSyncRef.current.getLocalInput(currentTick)
+          );
+        }
+      } else if (mode === "snapshot" && isHost) {
         const networked = actorRegistry.current.getNetworked();
         const entities = buildEntityMap(networked, is2D);
-        if (mode === "snapshot" || mode === "prediction") {
-          snapshotSyncRef.current?.hostTick(currentTick, entities, tickKeeper.tickDelta);
-        }
-        if (mode === "prediction") {
-          predictionSyncRef.current?.hostTick(currentTick, entities, tickKeeper.tickDelta);
-        }
-      } else {
-        if (mode === "prediction" && predictionSyncRef.current) {
-          predictionSyncRef.current.clientTick(currentTick);
-        }
+        snapshotSyncRef.current?.hostTick(currentTick, entities, tickKeeper.tickDelta);
       }
     }
-    if (!isHost) {
-      if (mode === "snapshot" && snapshotSyncRef.current) {
-        const renderTime = performance.now();
-        const interpolated = snapshotSyncRef.current.clientInterpolate(renderTime);
-        applyStatesToActors(interpolated, actorRegistry.current, is2D);
-      } else if (mode === "prediction" && predictionSyncRef.current) {
-        const predicted = predictionSyncRef.current.predictedState;
-        const smoothed = predictionSyncRef.current.applyErrorSmoothing(predicted);
-        applyStatesToActors(smoothed, actorRegistry.current, is2D);
+    if (!isHost && mode === "snapshot" && snapshotSyncRef.current) {
+      const renderTime = performance.now();
+      const interpolated = snapshotSyncRef.current.clientInterpolate(renderTime);
+      applyStatesToActors(interpolated, actorRegistry.current, is2D);
+    }
+    if (mode === "prediction" && predictionSyncRef.current) {
+      const offsets = predictionSyncRef.current.getRenderErrorOffsets();
+      for (const [id, off] of offsets) {
+        const ref = actorRegistry.current.get(id);
+        if (!ref) continue;
+        const pos = ref.object3D.position;
+        pos.x += off.x;
+        pos.y += off.y;
+        if (!is2D) pos.z += off.z;
+        let appliedA = 0;
+        let appliedQ = IDENTITY_QUAT2;
+        if (is2D) {
+          ref.object3D.rotation.z += off.a;
+          appliedA = off.a;
+        } else {
+          appliedQ = { x: off.qx, y: off.qy, z: off.qz, w: off.qw };
+          if (!isIdentityQuat(appliedQ)) {
+            const cur = ref.object3D.quaternion;
+            const r = quatMultiply(appliedQ, { x: cur.x, y: cur.y, z: cur.z, w: cur.w });
+            cur.set(r.x, r.y, r.z, r.w);
+          }
+        }
+        appliedErrorsRef.current.set(id, {
+          x: off.x,
+          y: off.y,
+          z: is2D ? 0 : off.z,
+          a: appliedA,
+          q: appliedQ,
+          px: pos.x,
+          py: pos.y,
+          pz: pos.z
+        });
       }
     }
     if (ticksThisFrame > 0) {
@@ -3289,7 +3849,8 @@ function useMultiplayer(options = {}) {
     tick,
     serverTick,
     drift,
-    syncEngine: mode
+    syncEngine: mode,
+    setInput
   };
 }
 
@@ -3801,11 +4362,13 @@ var InterestManager = class {
 0 && (module.exports = {
   DebugOverlay,
   FirebaseStrategy,
+  InputBuffer,
   InterestManager,
   MqttStrategy,
   MultiplayerBridge,
   MultiplayerProvider,
   NetworkSimulator,
+  computeJustPressed,
   useHost,
   useLobby,
   useMultiplayer,