@carverjs/multiplayer 0.0.1

package/dist/index.js

@@ -0,0 +1,3817 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DebugOverlay: () => DebugOverlay,
+  FirebaseStrategy: () => FirebaseStrategy,
+  InterestManager: () => InterestManager,
+  MqttStrategy: () => MqttStrategy,
+  MultiplayerBridge: () => MultiplayerBridge,
+  MultiplayerProvider: () => MultiplayerProvider,
+  NetworkSimulator: () => NetworkSimulator,
+  useHost: () => useHost,
+  useLobby: () => useLobby,
+  useMultiplayer: () => useMultiplayer,
+  useNetworkEvents: () => useNetworkEvents,
+  useNetworkState: () => useNetworkState,
+  usePlayers: () => usePlayers,
+  useRoom: () => useRoom
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/components/MultiplayerProvider.ts
+var import_react2 = require("react");
+
+// src/transport/strategy/utils.ts
+function generatePeerId() {
+  const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  const bytes = new Uint8Array(20);
+  crypto.getRandomValues(bytes);
+  let id = "";
+  for (let i = 0; i < 20; i++) {
+    id += chars[bytes[i] % chars.length];
+  }
+  return id;
+}
+function mqttTopics(appId, roomId, peerId) {
+  const base = `carver/${appId}`;
+  return {
+    /** Lobby wildcard: subscribe to discover all room announcements */
+    lobbyWildcard: `${base}/lobby/+`,
+    /** Single room lobby entry */
+    roomLobbyEntry: `${base}/lobby/${roomId}`,
+    /** Wildcard for all peer presence in a room */
+    roomPresenceWildcard: `${base}/room/${roomId}/presence/+`,
+    /** This peer's presence topic */
+    peerPresence: peerId ? `${base}/room/${roomId}/presence/${peerId}` : "",
+    /** This peer's signal inbox */
+    peerSignalInbox: peerId ? `${base}/room/${roomId}/signal/${peerId}` : ""
+  };
+}
+function firebasePaths(appId, roomId, peerId) {
+  const base = `${appId}/__carver__`;
+  return {
+    lobby: `${base}/lobby`,
+    roomLobbyEntry: `${base}/lobby/${roomId}`,
+    peers: `${base}/rooms/${roomId}/peers`,
+    peerPresence: peerId ? `${base}/rooms/${roomId}/peers/${peerId}` : "",
+    peerSignalInbox: peerId ? `${base}/rooms/${roomId}/signals/${peerId}` : ""
+  };
+}
+var DEFAULT_MQTT_BROKERS = [
+  "wss://broker.emqx.io:8084/mqtt",
+  "wss://test.mosquitto.org:8081/mqtt"
+];
+var ROOM_ANNOUNCE_EXPIRY_MS = 3e4;
+var ROOM_ANNOUNCE_INTERVAL_MS = 1e4;
+var PRESENCE_HEARTBEAT_MS = 5e3;
+var PEER_EXPIRY_MS = PRESENCE_HEARTBEAT_MS * 3;
+var PRESENCE_WARMUP_DELAYS_MS = [200, 500, 1500];
+function removeFromArray(arr, item) {
+  const idx = arr.indexOf(item);
+  if (idx >= 0) {
+    arr.splice(idx, 1);
+    return true;
+  }
+  return false;
+}
+
+// src/transport/strategy/mqtt.ts
+var MqttStrategy = class {
+  constructor(appId, config = { type: "mqtt" }) {
+    this._client = null;
+    this._roomId = null;
+    this._peerMeta = {};
+    /** Monotonic counter to detect stale leaveRoom completions */
+    this._joinGeneration = 0;
+    // Lazy init
+    this._initPromise = null;
+    // Callbacks
+    this._onPeerDiscovered = [];
+    this._onPeerLeft = [];
+    this._onSignal = [];
+    this._onLobby = [];
+    // State
+    this._knownPeers = /* @__PURE__ */ new Map();
+    this._lobbyRooms = /* @__PURE__ */ new Map();
+    this._presenceTimer = null;
+    this._warmupTimers = [];
+    this._lobbyAnnounceTimer = null;
+    this._peerExpiryTimer = null;
+    this._lobbySubscribed = false;
+    this._destroyed = false;
+    this.selfId = generatePeerId();
+    this._appId = appId;
+    this._config = config;
+  }
+  // ── Public API ──
+  async init() {
+    return this._ensureInit();
+  }
+  async joinRoom(roomId, peerMeta) {
+    await this._ensureInit();
+    if (!this._client) throw new Error("MQTT client not available");
+    this._joinGeneration++;
+    this._roomId = roomId;
+    this._peerMeta = peerMeta;
+    const topics = mqttTopics(this._appId, roomId, this.selfId);
+    await new Promise((resolve, reject) => {
+      this._client.subscribe(
+        [topics.roomPresenceWildcard, topics.peerSignalInbox],
+        { qos: 1 },
+        (err) => err ? reject(err) : resolve()
+      );
+    });
+    this._publishPresence();
+    for (const delay of PRESENCE_WARMUP_DELAYS_MS) {
+      this._warmupTimers.push(setTimeout(() => this._publishPresence(), delay));
+    }
+    this._presenceTimer = setInterval(() => this._publishPresence(), PRESENCE_HEARTBEAT_MS);
+    this._peerExpiryTimer = setInterval(() => this._checkPeerExpiry(), PRESENCE_HEARTBEAT_MS);
+  }
+  async leaveRoom() {
+    if (!this._client || !this._roomId) return;
+    const generation = this._joinGeneration;
+    const topics = mqttTopics(this._appId, this._roomId, this.selfId);
+    this._clearRoomTimers();
+    this._client.publish(topics.peerPresence, "", { retain: true, qos: 1 });
+    this._client.unsubscribe([topics.roomPresenceWildcard, topics.peerSignalInbox]);
+    this._knownPeers.clear();
+    if (this._joinGeneration === generation) {
+      this._roomId = null;
+    }
+  }
+  signal(targetPeerId, data) {
+    if (!this._client || !this._roomId) return;
+    const targetTopic = `carver/${this._appId}/room/${this._roomId}/signal/${targetPeerId}`;
+    this._client.publish(
+      targetTopic,
+      JSON.stringify({ from: this.selfId, data, ts: Date.now() }),
+      { qos: 1 }
+    );
+  }
+  subscribeToLobby(cb) {
+    this._onLobby.push(cb);
+    if (!this._lobbySubscribed) {
+      this._lobbySubscribed = true;
+      this._ensureInit().then(() => {
+        if (this._client && !this._destroyed) {
+          const lobbyTopic = mqttTopics(this._appId, "", "").lobbyWildcard;
+          this._client.subscribe(lobbyTopic, { qos: 0 });
+        }
+      });
+    }
+    return () => {
+      removeFromArray(this._onLobby, cb);
+    };
+  }
+  announceRoom(announcement) {
+    if (!this._client) return;
+    const topic = mqttTopics(this._appId, announcement.roomId, "").roomLobbyEntry;
+    announcement.lastSeen = Date.now();
+    this._client.publish(topic, JSON.stringify(announcement), { retain: true, qos: 1 });
+    if (this._lobbyAnnounceTimer) clearInterval(this._lobbyAnnounceTimer);
+    this._lobbyAnnounceTimer = setInterval(() => {
+      announcement.lastSeen = Date.now();
+      this._client?.publish(topic, JSON.stringify(announcement), { retain: true, qos: 1 });
+    }, ROOM_ANNOUNCE_INTERVAL_MS);
+  }
+  removeRoomAnnouncement(roomId) {
+    if (!this._client) return;
+    const topic = mqttTopics(this._appId, roomId, "").roomLobbyEntry;
+    this._client.publish(topic, "", { retain: true, qos: 1 });
+    if (this._lobbyAnnounceTimer) {
+      clearInterval(this._lobbyAnnounceTimer);
+      this._lobbyAnnounceTimer = null;
+    }
+  }
+  onPeerDiscovered(cb) {
+    this._onPeerDiscovered.push(cb);
+    return () => {
+      removeFromArray(this._onPeerDiscovered, cb);
+    };
+  }
+  onPeerLeft(cb) {
+    this._onPeerLeft.push(cb);
+    return () => {
+      removeFromArray(this._onPeerLeft, cb);
+    };
+  }
+  onSignal(cb) {
+    this._onSignal.push(cb);
+    return () => {
+      removeFromArray(this._onSignal, cb);
+    };
+  }
+  destroy() {
+    this._destroyed = true;
+    this._clearRoomTimers();
+    if (this._client && this._roomId) {
+      const topics = mqttTopics(this._appId, this._roomId, this.selfId);
+      this._client.publish(topics.peerPresence, "", { retain: true, qos: 1 });
+    }
+    this._client?.end(true);
+    this._client = null;
+    this._knownPeers.clear();
+    this._lobbyRooms.clear();
+    this._onPeerDiscovered = [];
+    this._onPeerLeft = [];
+    this._onSignal = [];
+    this._onLobby = [];
+  }
+  // ── Private ──
+  _ensureInit() {
+    if (!this._initPromise) {
+      this._initPromise = this._doInit();
+    }
+    return this._initPromise;
+  }
+  async _doInit() {
+    const mqtt = await import("mqtt");
+    const brokers = this._config.brokerUrls ?? DEFAULT_MQTT_BROKERS;
+    const brokerUrl = brokers[Math.floor(Math.random() * brokers.length)];
+    return new Promise((resolve, reject) => {
+      const connectFn = mqtt.default?.connect ?? mqtt.connect;
+      this._client = connectFn(brokerUrl, {
+        clientId: `carver_${this.selfId}`,
+        clean: true,
+        connectTimeout: 1e4,
+        keepalive: 30
+      });
+      this._client.on("connect", () => {
+        if (!this._destroyed) resolve();
+      });
+      this._client.on("error", (err) => {
+        if (!this._initPromise) return;
+        reject(err);
+      });
+      this._client.on("message", (topic, payload) => {
+        this._handleMessage(topic, payload);
+      });
+    });
+  }
+  _publishPresence() {
+    if (!this._client || !this._roomId) return;
+    const topics = mqttTopics(this._appId, this._roomId, this.selfId);
+    this._client.publish(
+      topics.peerPresence,
+      JSON.stringify({ peerId: this.selfId, meta: this._peerMeta, ts: Date.now() }),
+      { retain: true, qos: 1 }
+    );
+  }
+  _handleMessage(topic, payload) {
+    const raw = payload.toString();
+    const presenceMatch = topic.match(/\/room\/[^/]+\/presence\/([^/]+)$/);
+    if (presenceMatch) {
+      const peerId = presenceMatch[1];
+      if (peerId === this.selfId) return;
+      if (!raw) {
+        if (this._knownPeers.has(peerId)) {
+          this._knownPeers.delete(peerId);
+          for (const cb of this._onPeerLeft) cb(peerId);
+        }
+        return;
+      }
+      try {
+        const msg = JSON.parse(raw);
+        const isNew = !this._knownPeers.has(peerId);
+        this._knownPeers.set(peerId, { meta: msg.meta ?? {}, lastSeen: msg.ts ?? Date.now() });
+        if (isNew) {
+          for (const cb of this._onPeerDiscovered) cb(peerId, msg.meta ?? {});
+        }
+      } catch {
+      }
+      return;
+    }
+    const signalMatch = topic.match(/\/room\/[^/]+\/signal\/([^/]+)$/);
+    if (signalMatch) {
+      try {
+        const msg = JSON.parse(raw);
+        if (msg.from && msg.from !== this.selfId) {
+          for (const cb of this._onSignal) cb(msg.from, msg.data);
+        }
+      } catch {
+      }
+      return;
+    }
+    const lobbyMatch = topic.match(/\/lobby\/([^/]+)$/);
+    if (lobbyMatch) {
+      const roomId = lobbyMatch[1];
+      if (!raw) {
+        this._lobbyRooms.delete(roomId);
+      } else {
+        try {
+          const ann = JSON.parse(raw);
+          if (Date.now() - ann.lastSeen < ROOM_ANNOUNCE_EXPIRY_MS) {
+            this._lobbyRooms.set(roomId, ann);
+          } else {
+            this._lobbyRooms.delete(roomId);
+          }
+        } catch {
+        }
+      }
+      const rooms = Array.from(this._lobbyRooms.values());
+      for (const cb of this._onLobby) cb(rooms);
+    }
+  }
+  _checkPeerExpiry() {
+    const now = Date.now();
+    for (const [peerId, data] of this._knownPeers) {
+      if (now - data.lastSeen > PEER_EXPIRY_MS) {
+        this._knownPeers.delete(peerId);
+        for (const cb of this._onPeerLeft) cb(peerId);
+      }
+    }
+  }
+  _clearRoomTimers() {
+    if (this._presenceTimer) {
+      clearInterval(this._presenceTimer);
+      this._presenceTimer = null;
+    }
+    for (const t of this._warmupTimers) clearTimeout(t);
+    this._warmupTimers = [];
+    if (this._lobbyAnnounceTimer) {
+      clearInterval(this._lobbyAnnounceTimer);
+      this._lobbyAnnounceTimer = null;
+    }
+    if (this._peerExpiryTimer) {
+      clearInterval(this._peerExpiryTimer);
+      this._peerExpiryTimer = null;
+    }
+  }
+};
+
+// src/transport/strategy/firebase.ts
+var FirebaseStrategy = class {
+  constructor(appId, config) {
+    this._db = null;
+    this._firebaseApp = null;
+    this._ownApp = false;
+    this._roomId = null;
+    this._peerMeta = {};
+    /** Monotonic counter to detect stale leaveRoom completions */
+    this._joinGeneration = 0;
+    // Lazy init
+    this._initPromise = null;
+    // Firebase module references (filled after dynamic import)
+    this._fb = null;
+    // Unsubscribe handles for Firebase listeners
+    this._listeners = [];
+    // Callbacks
+    this._onPeerDiscovered = [];
+    this._onPeerLeft = [];
+    this._onSignal = [];
+    this._onLobby = [];
+    // State
+    this._knownPeers = /* @__PURE__ */ new Set();
+    this._lobbyAnnounceTimer = null;
+    this._destroyed = false;
+    this.selfId = generatePeerId();
+    this._appId = appId;
+    this._config = config;
+  }
+  // ── Public API ──
+  async init() {
+    return this._ensureInit();
+  }
+  async joinRoom(roomId, peerMeta) {
+    await this._ensureInit();
+    if (!this._db || !this._fb) throw new Error("Firebase not initialized");
+    this._joinGeneration++;
+    this._roomId = roomId;
+    this._peerMeta = peerMeta;
+    const { ref, set, onChildAdded, onChildRemoved, onDisconnect, remove } = this._fb;
+    const paths = firebasePaths(this._appId, roomId, this.selfId);
+    await remove(ref(this._db, paths.peerSignalInbox)).catch(() => {
+    });
+    const presenceRef = ref(this._db, paths.peerPresence);
+    await set(presenceRef, {
+      peerId: this.selfId,
+      meta: peerMeta,
+      ts: Date.now()
+    });
+    onDisconnect(presenceRef).remove();
+    const peersRef = ref(this._db, paths.peers);
+    const addedUnsub = onChildAdded(peersRef, (snapshot) => {
+      const data = snapshot.val();
+      if (!data || data.peerId === this.selfId) return;
+      if (!this._knownPeers.has(data.peerId)) {
+        this._knownPeers.add(data.peerId);
+        for (const cb of this._onPeerDiscovered) cb(data.peerId, data.meta ?? {});
+      }
+    });
+    this._listeners.push(() => addedUnsub());
+    const removedUnsub = onChildRemoved(peersRef, (snapshot) => {
+      const data = snapshot.val();
+      const peerId = data?.peerId ?? snapshot.key;
+      if (peerId && this._knownPeers.has(peerId)) {
+        this._knownPeers.delete(peerId);
+        for (const cb of this._onPeerLeft) cb(peerId);
+      }
+    });
+    this._listeners.push(() => removedUnsub());
+    const signalRef = ref(this._db, paths.peerSignalInbox);
+    const signalUnsub = onChildAdded(signalRef, (snapshot) => {
+      const msg = snapshot.val();
+      if (!msg || msg.from === this.selfId) return;
+      for (const cb of this._onSignal) cb(msg.from, msg.data);
+      remove(snapshot.ref);
+    });
+    this._listeners.push(() => signalUnsub());
+  }
+  async leaveRoom() {
+    if (!this._db || !this._fb || !this._roomId) return;
+    const leavingRoomId = this._roomId;
+    const generation = this._joinGeneration;
+    const { ref, remove } = this._fb;
+    const paths = firebasePaths(this._appId, leavingRoomId, this.selfId);
+    for (const unsub of this._listeners) unsub();
+    this._listeners = [];
+    await Promise.all([
+      remove(ref(this._db, paths.peerPresence)),
+      remove(ref(this._db, paths.peerSignalInbox))
+    ]).catch(() => {
+    });
+    if (this._lobbyAnnounceTimer) {
+      clearInterval(this._lobbyAnnounceTimer);
+      this._lobbyAnnounceTimer = null;
+    }
+    this._knownPeers.clear();
+    if (this._joinGeneration === generation) {
+      this._roomId = null;
+    }
+  }
+  signal(targetPeerId, data) {
+    if (!this._db || !this._fb || !this._roomId) return;
+    const { ref, push } = this._fb;
+    const inboxPath = firebasePaths(this._appId, this._roomId, targetPeerId).peerSignalInbox;
+    push(ref(this._db, inboxPath), {
+      from: this.selfId,
+      data: sanitizeForFirebase(data),
+      ts: Date.now()
+    });
+  }
+  subscribeToLobby(cb) {
+    this._onLobby.push(cb);
+    this._ensureInit().then(() => {
+      if (!this._db || !this._fb || this._destroyed) return;
+      const { ref, onValue } = this._fb;
+      const paths = firebasePaths(this._appId, "", "");
+      const lobbyRef = ref(this._db, paths.lobby);
+      const unsub = onValue(lobbyRef, (snapshot) => {
+        const data = snapshot.val();
+        if (!data) {
+          for (const lcb of this._onLobby) lcb([]);
+          return;
+        }
+        const now = Date.now();
+        const rooms = Object.values(data).filter(
+          (r) => r && now - (r.lastSeen ?? 0) < ROOM_ANNOUNCE_EXPIRY_MS
+        );
+        for (const lcb of this._onLobby) lcb(rooms);
+      });
+      this._listeners.push(() => unsub());
+    });
+    return () => {
+      removeFromArray(this._onLobby, cb);
+    };
+  }
+  announceRoom(announcement) {
+    if (!this._db || !this._fb) return;
+    const { ref, set } = this._fb;
+    const paths = firebasePaths(this._appId, announcement.roomId, "");
+    announcement.lastSeen = Date.now();
+    set(ref(this._db, paths.roomLobbyEntry), announcement);
+    if (this._lobbyAnnounceTimer) clearInterval(this._lobbyAnnounceTimer);
+    this._lobbyAnnounceTimer = setInterval(() => {
+      announcement.lastSeen = Date.now();
+      set(ref(this._db, paths.roomLobbyEntry), announcement);
+    }, ROOM_ANNOUNCE_INTERVAL_MS);
+  }
+  removeRoomAnnouncement(roomId) {
+    if (!this._db || !this._fb) return;
+    const { ref, remove } = this._fb;
+    remove(ref(this._db, firebasePaths(this._appId, roomId, "").roomLobbyEntry));
+    if (this._lobbyAnnounceTimer) {
+      clearInterval(this._lobbyAnnounceTimer);
+      this._lobbyAnnounceTimer = null;
+    }
+  }
+  onPeerDiscovered(cb) {
+    this._onPeerDiscovered.push(cb);
+    return () => {
+      removeFromArray(this._onPeerDiscovered, cb);
+    };
+  }
+  onPeerLeft(cb) {
+    this._onPeerLeft.push(cb);
+    return () => {
+      removeFromArray(this._onPeerLeft, cb);
+    };
+  }
+  onSignal(cb) {
+    this._onSignal.push(cb);
+    return () => {
+      removeFromArray(this._onSignal, cb);
+    };
+  }
+  destroy() {
+    this._destroyed = true;
+    for (const unsub of this._listeners) unsub();
+    this._listeners = [];
+    if (this._lobbyAnnounceTimer) {
+      clearInterval(this._lobbyAnnounceTimer);
+      this._lobbyAnnounceTimer = null;
+    }
+    if (this._db && this._fb && this._roomId) {
+      const { ref, remove } = this._fb;
+      const paths = firebasePaths(this._appId, this._roomId, this.selfId);
+      remove(ref(this._db, paths.peerPresence)).catch(() => {
+      });
+      remove(ref(this._db, paths.peerSignalInbox)).catch(() => {
+      });
+    }
+    if (this._ownApp && this._firebaseApp) {
+      import("firebase/app").then(({ deleteApp }) => {
+        deleteApp(this._firebaseApp).catch(() => {
+        });
+      });
+    }
+    this._db = null;
+    this._firebaseApp = null;
+    this._fb = null;
+    this._knownPeers.clear();
+    this._onPeerDiscovered = [];
+    this._onPeerLeft = [];
+    this._onSignal = [];
+    this._onLobby = [];
+  }
+  // ── Private ──
+  _ensureInit() {
+    if (!this._initPromise) {
+      this._initPromise = this._doInit();
+    }
+    return this._initPromise;
+  }
+  async _doInit() {
+    const { initializeApp, getApps } = await import("firebase/app");
+    const {
+      getDatabase,
+      ref,
+      set,
+      push,
+      remove,
+      onValue,
+      onChildAdded,
+      onChildRemoved,
+      onDisconnect
+    } = await import("firebase/database");
+    this._fb = { ref, set, push, remove, onValue, onChildAdded, onChildRemoved, onDisconnect };
+    if (this._config.firebaseApp) {
+      this._firebaseApp = this._config.firebaseApp;
+      this._ownApp = false;
+    } else {
+      const appName = `carver_${this._appId}`;
+      const existing = getApps().find((a) => a.name === appName);
+      if (existing) {
+        this._firebaseApp = existing;
+        this._ownApp = false;
+      } else {
+        this._firebaseApp = initializeApp({ databaseURL: this._config.databaseURL }, appName);
+        this._ownApp = true;
+      }
+    }
+    this._db = getDatabase(this._firebaseApp);
+  }
+};
+function sanitizeForFirebase(obj) {
+  if (obj === null) return "__null__";
+  if (Array.isArray(obj)) return obj.map(sanitizeForFirebase);
+  if (typeof obj === "object" && obj !== null) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+      result[key] = value === null ? "__null__" : sanitizeForFirebase(value);
+    }
+    return result;
+  }
+  return obj;
+}
+
+// src/core/TickKeeper.ts
+var _TickKeeper = class _TickKeeper {
+  constructor(tickRate = 60) {
+    this._accumulator = 0;
+    this._tick = 0;
+    this._serverTick = 0;
+    this._alpha = 0;
+    this._timeScale = 1;
+    this._tickRate = tickRate;
+    this._tickDelta = 1 / tickRate;
+  }
+  get tick() {
+    return this._tick;
+  }
+  get serverTick() {
+    return this._serverTick;
+  }
+  get tickDelta() {
+    return this._tickDelta;
+  }
+  get tickRate() {
+    return this._tickRate;
+  }
+  /** Interpolation alpha for rendering between ticks (0-1) */
+  get alpha() {
+    return this._alpha;
+  }
+  /** Current time scale (affected by drift correction) */
+  get timeScale() {
+    return this._timeScale;
+  }
+  /** Ticks ahead of server (positive = ahead, negative = behind) */
+  get drift() {
+    return this._tick - this._serverTick;
+  }
+  /** Update server tick from received snapshot */
+  setServerTick(serverTick) {
+    this._serverTick = serverTick;
+    this._updateDriftCorrection();
+  }
+  /**
+   * Accumulate time and return the number of fixed ticks to process.
+   * Call this once per render frame with the raw frame delta.
+   */
+  update(rawDelta) {
+    const maxDelta = this._tickDelta * 8;
+    const delta = Math.min(rawDelta, maxDelta) * this._timeScale;
+    this._accumulator += delta;
+    let ticksThisFrame = 0;
+    while (this._accumulator >= this._tickDelta) {
+      this._accumulator -= this._tickDelta;
+      this._tick++;
+      ticksThisFrame++;
+    }
+    this._alpha = this._accumulator / this._tickDelta;
+    return ticksThisFrame;
+  }
+  /** Reset to initial state */
+  reset() {
+    this._accumulator = 0;
+    this._tick = 0;
+    this._serverTick = 0;
+    this._alpha = 0;
+    this._timeScale = 1;
+  }
+  /** Set tick rate (updates tickDelta accordingly) */
+  setTickRate(rate) {
+    this._tickRate = rate;
+    this._tickDelta = 1 / rate;
+  }
+  _updateDriftCorrection() {
+    const drift = this.drift;
+    if (drift < _TickKeeper.DRIFT_BEHIND_THRESHOLD) {
+      this._timeScale = _TickKeeper.SPEED_UP_SCALE;
+    } else if (drift > _TickKeeper.DRIFT_AHEAD_THRESHOLD) {
+      this._timeScale = _TickKeeper.SLOW_DOWN_SCALE;
+    } else {
+      this._timeScale = _TickKeeper.NORMAL_SCALE;
+    }
+  }
+};
+// Drift correction zones
+_TickKeeper.DRIFT_BEHIND_THRESHOLD = -5;
+_TickKeeper.DRIFT_AHEAD_THRESHOLD = 5;
+_TickKeeper.SPEED_UP_SCALE = 1.5;
+_TickKeeper.SLOW_DOWN_SCALE = 0.1;
+_TickKeeper.NORMAL_SCALE = 1;
+var TickKeeper = _TickKeeper;
+
+// src/core/codec.ts
+var import_msgpackr = require("msgpackr");
+var DEFAULT_THRESHOLDS = {
+  position: 0.01,
+  rotation: 1e-3,
+  velocity: 0.05,
+  custom: "strict"
+};
+var SnapshotBuffer = class {
+  constructor(capacity = 120) {
+    this._capacity = capacity;
+    this._buffer = /* @__PURE__ */ new Map();
+  }
+  /** Store a snapshot at the given tick */
+  store(tick, entities) {
+    this._buffer.set(tick, entities);
+    if (this._buffer.size > this._capacity) {
+      const sortedTicks = Array.from(this._buffer.keys()).sort((a, b) => a - b);
+      const toRemove = sortedTicks.length - this._capacity;
+      for (let i = 0; i < toRemove; i++) {
+        this._buffer.delete(sortedTicks[i]);
+      }
+    }
+  }
+  /** Get a snapshot at the given tick */
+  get(tick) {
+    return this._buffer.get(tick);
+  }
+  /** Clear all stored snapshots */
+  clear() {
+    this._buffer.clear();
+  }
+};
+var Codec = class {
+  constructor(options) {
+    this._thresholds = { ...DEFAULT_THRESHOLDS, ...options?.thresholds };
+    this._quantize = options?.quantize;
+    this._is2D = options?.is2D ?? false;
+  }
+  /** Serialize entity states to binary (msgpackr) */
+  serialize(entities) {
+    const quantized = this._quantize ? entities.map((e) => this._quantizeEntity(e)) : entities;
+    return (0, import_msgpackr.pack)(quantized);
+  }
+  /** Deserialize binary to entity states */
+  deserialize(data) {
+    return (0, import_msgpackr.unpack)(data);
+  }
+  /**
+   * Compute delta: only include entities that changed beyond thresholds
+   * since the baseline snapshot.
+   * Returns null if nothing changed.
+   */
+  computeDelta(current, baseline) {
+    if (!baseline) {
+      return Array.from(current.values());
+    }
+    const changed = [];
+    for (const [id, entity] of current) {
+      const prev = baseline.get(id);
+      if (!prev || this._hasChanged(entity, prev)) {
+        changed.push(entity);
+      }
+    }
+    for (const id of baseline.keys()) {
+      if (!current.has(id)) {
+        if (this._is2D) {
+          changed.push({ id, x: 0, y: 0, a: 0, vx: 0, vy: 0, va: 0, c: { __removed: true } });
+        } else {
+          changed.push({ id, x: 0, y: 0, z: 0, qx: 0, qy: 0, qz: 0, qw: 1, vx: 0, vy: 0, vz: 0, wx: 0, wy: 0, wz: 0, c: { __removed: true } });
+        }
+      }
+    }
+    return changed.length > 0 ? changed : null;
+  }
+  /** Serialize a delta snapshot packet */
+  serializeDelta(tick, baseTick, current, baseline) {
+    const delta = this.computeDelta(current, baseline);
+    if (!delta) return null;
+    const packet = {
+      t: tick,
+      b: baseline ? baseTick : -1,
+      // -1 = keyframe
+      s: this.serialize(delta)
+    };
+    return (0, import_msgpackr.pack)(packet);
+  }
+  /** Deserialize a snapshot packet */
+  deserializePacket(data) {
+    const packet = (0, import_msgpackr.unpack)(data);
+    return {
+      tick: packet.t,
+      baseTick: packet.b,
+      entities: this.deserialize(packet.s)
+    };
+  }
+  _hasChanged(current, prev) {
+    const t = this._thresholds;
+    if (Math.abs(current.x - prev.x) > t.position) return true;
+    if (Math.abs(current.y - prev.y) > t.position) return true;
+    if ("z" in current && "z" in prev) {
+      const c = current;
+      const p = prev;
+      if (Math.abs(c.z - p.z) > t.position) return true;
+      if (Math.abs(c.qx - p.qx) > t.rotation) return true;
+      if (Math.abs(c.qy - p.qy) > t.rotation) return true;
+      if (Math.abs(c.qz - p.qz) > t.rotation) return true;
+      if (Math.abs(c.qw - p.qw) > t.rotation) return true;
+      if (Math.abs(c.vx - p.vx) > t.velocity) return true;
+      if (Math.abs(c.vy - p.vy) > t.velocity) return true;
+      if (Math.abs(c.vz - p.vz) > t.velocity) return true;
+      if (Math.abs(c.wx - p.wx) > t.velocity) return true;
+      if (Math.abs(c.wy - p.wy) > t.velocity) return true;
+      if (Math.abs(c.wz - p.wz) > t.velocity) return true;
+    } else {
+      const c = current;
+      const p = prev;
+      if (Math.abs(c.a - p.a) > t.rotation) return true;
+      if (Math.abs(c.vx - p.vx) > t.velocity) return true;
+      if (Math.abs(c.vy - p.vy) > t.velocity) return true;
+      if (Math.abs(c.va - p.va) > t.velocity) return true;
+    }
+    if (current.c || prev.c) {
+      const cc = current.c ?? {};
+      const pc = prev.c ?? {};
+      const allKeys = /* @__PURE__ */ new Set([...Object.keys(cc), ...Object.keys(pc)]);
+      for (const key of allKeys) {
+        if (t.custom === "strict") {
+          if (cc[key] !== pc[key]) return true;
+        } else {
+          const diff = typeof cc[key] === "number" && typeof pc[key] === "number" ? Math.abs(cc[key] - pc[key]) : cc[key] === pc[key] ? 0 : 1;
+          if (diff > t.custom) return true;
+        }
+      }
+    }
+    return false;
+  }
+  _quantizeEntity(entity) {
+    const q = this._quantize;
+    const result = { ...entity };
+    if (q.position !== void 0) {
+      const m = Math.pow(10, q.position);
+      result.x = Math.round(result.x * m) / m;
+      result.y = Math.round(result.y * m) / m;
+      if ("z" in result) {
+        result.z = Math.round(result.z * m) / m;
+      }
+    }
+    if (q.rotation !== void 0) {
+      const m = Math.pow(10, q.rotation);
+      if ("a" in result) {
+        result.a = Math.round(result.a * m) / m;
+      } else if ("qx" in result) {
+        const r = result;
+        r.qx = Math.round(r.qx * m) / m;
+        r.qy = Math.round(r.qy * m) / m;
+        r.qz = Math.round(r.qz * m) / m;
+        r.qw = Math.round(r.qw * m) / m;
+      }
+    }
+    if (q.velocity !== void 0) {
+      const m = Math.pow(10, q.velocity);
+      result.vx = Math.round(result.vx * m) / m;
+      result.vy = Math.round(result.vy * m) / m;
+      if ("vz" in result) {
+        const r = result;
+        r.vz = Math.round(r.vz * m) / m;
+        r.wx = Math.round(r.wx * m) / m;
+        r.wy = Math.round(r.wy * m) / m;
+        r.wz = Math.round(r.wz * m) / m;
+      }
+      if ("va" in result) {
+        result.va = Math.round(result.va * m) / m;
+      }
+    }
+    return result;
+  }
+};
+
+// src/core/NetworkManager.ts
+var NetworkManager = class {
+  constructor(options = {}) {
+    // Transport
+    this._transport = null;
+    this._connectionState = "disconnected";
+    // Room state
+    this._room = null;
+    this._players = /* @__PURE__ */ new Map();
+    // Sync state
+    this._syncMode = "snapshot";
+    this._networkQuality = "good";
+    // Change listeners
+    this._connectionListeners = [];
+    this._playerListeners = [];
+    this._roomListeners = [];
+    this._errorListeners = [];
+    this._options = options;
+    this._syncMode = options.mode ?? "snapshot";
+    this._tickKeeper = new TickKeeper(options.tickRate ?? 60);
+    this._codec = new Codec({
+      thresholds: options.deltaThresholds,
+      quantize: options.quantize
+    });
+    this._snapshotBuffer = new SnapshotBuffer();
+  }
+  // -- Getters --
+  get transport() {
+    return this._transport;
+  }
+  get connectionState() {
+    return this._connectionState;
+  }
+  get room() {
+    return this._room;
+  }
+  get players() {
+    return this._players;
+  }
+  get selfId() {
+    return this._transport?.peerId || null;
+  }
+  get isHost() {
+    return this._transport?.isHost ?? false;
+  }
+  get hostId() {
+    return this._transport?.hostId ?? null;
+  }
+  get syncMode() {
+    return this._syncMode;
+  }
+  get tickKeeper() {
+    return this._tickKeeper;
+  }
+  get codec() {
+    return this._codec;
+  }
+  get snapshotBuffer() {
+    return this._snapshotBuffer;
+  }
+  get networkQuality() {
+    return this._networkQuality;
+  }
+  get options() {
+    return this._options;
+  }
+  // -- Transport management --
+  setTransport(transport) {
+    this._transport = transport;
+    transport.onPeerJoin((peerId) => {
+      if (!this._players.has(peerId)) {
+        this._players.set(peerId, {
+          peerId,
+          displayName: `Player-${peerId.slice(0, 4)}`,
+          isHost: peerId === transport.hostId,
+          isSelf: false,
+          isReady: false,
+          isConnected: true,
+          metadata: {},
+          latencyMs: 0,
+          joinedAt: Date.now()
+        });
+      }
+      this._notifyPlayerListeners();
+    });
+    transport.onPeerUpdated((player) => {
+      this._players.set(player.peerId, {
+        ...player,
+        isSelf: player.peerId === this.selfId
+      });
+      this._notifyPlayerListeners();
+    });
+    transport.onPeerLeave((peerId) => {
+      this._players.delete(peerId);
+      this._notifyPlayerListeners();
+    });
+    transport.onHostChanged((_newHostId) => {
+      this._notifyRoomListeners();
+    });
+  }
+  // -- Connection state --
+  setConnectionState(state) {
+    this._connectionState = state;
+    for (const listener of this._connectionListeners) listener(state);
+  }
+  onConnectionStateChange(cb) {
+    this._connectionListeners.push(cb);
+    return () => {
+      const idx = this._connectionListeners.indexOf(cb);
+      if (idx >= 0) this._connectionListeners.splice(idx, 1);
+    };
+  }
+  // -- Room state --
+  setRoom(room) {
+    this._room = room;
+    this._notifyRoomListeners();
+  }
+  onRoomChange(cb) {
+    this._roomListeners.push(cb);
+    return () => {
+      const idx = this._roomListeners.indexOf(cb);
+      if (idx >= 0) this._roomListeners.splice(idx, 1);
+    };
+  }
+  // -- Players --
+  setPlayers(players) {
+    this._players.clear();
+    for (const p of players) {
+      this._players.set(p.peerId, p);
+    }
+    this._notifyPlayerListeners();
+  }
+  updatePlayer(player) {
+    this._players.set(player.peerId, player);
+    this._notifyPlayerListeners();
+  }
+  removePlayer(peerId) {
+    this._players.delete(peerId);
+    this._notifyPlayerListeners();
+  }
+  onPlayersChange(cb) {
+    this._playerListeners.push(cb);
+    return () => {
+      const idx = this._playerListeners.indexOf(cb);
+      if (idx >= 0) this._playerListeners.splice(idx, 1);
+    };
+  }
+  // -- Errors --
+  emitError(error) {
+    for (const listener of this._errorListeners) listener(error);
+  }
+  onError(cb) {
+    this._errorListeners.push(cb);
+    return () => {
+      const idx = this._errorListeners.indexOf(cb);
+      if (idx >= 0) this._errorListeners.splice(idx, 1);
+    };
+  }
+  // -- Network quality --
+  setNetworkQuality(quality) {
+    this._networkQuality = quality;
+  }
+  // -- Sync options --
+  updateOptions(options) {
+    this._options = options;
+    if (options.mode) this._syncMode = options.mode;
+    if (options.tickRate) this._tickKeeper.setTickRate(options.tickRate);
+    if (options.deltaThresholds || options.quantize) {
+      this._codec = new Codec({
+        thresholds: options.deltaThresholds,
+        quantize: options.quantize
+      });
+    }
+  }
+  // -- Cleanup --
+  destroy() {
+    this._transport?.disconnect();
+    this._transport = null;
+    this._connectionState = "disconnected";
+    this._room = null;
+    this._players.clear();
+    this._tickKeeper.reset();
+    this._snapshotBuffer.clear();
+    this._connectionListeners = [];
+    this._playerListeners = [];
+    this._roomListeners = [];
+    this._errorListeners = [];
+  }
+  // -- Private --
+  _notifyPlayerListeners() {
+    for (const listener of this._playerListeners) listener();
+  }
+  _notifyRoomListeners() {
+    for (const listener of this._roomListeners) listener();
+  }
+};
+
+// src/core/MultiplayerContext.ts
+var import_react = require("react");
+var MultiplayerContext = (0, import_react.createContext)(null);
+function useMultiplayerContext() {
+  const ctx = (0, import_react.useContext)(MultiplayerContext);
+  if (!ctx) {
+    throw new Error("useMultiplayerContext must be used inside a <MultiplayerProvider>.");
+  }
+  return ctx;
+}
+
+// src/components/MultiplayerProvider.ts
+function createStrategy(appId, config) {
+  if (!config || config.type === "mqtt") {
+    return new MqttStrategy(appId, config ?? { type: "mqtt" });
+  }
+  if (config.type === "firebase") {
+    return new FirebaseStrategy(appId, config);
+  }
+  throw new Error(`Unknown strategy type: ${config.type}`);
+}
+function MultiplayerProvider({
+  appId,
+  strategy: strategyConfig,
+  iceServers,
+  children
+}) {
+  const managerRef = (0, import_react2.useRef)(null);
+  const strategyRef = (0, import_react2.useRef)(null);
+  if (!managerRef.current) {
+    managerRef.current = new NetworkManager();
+  }
+  if (!strategyRef.current) {
+    strategyRef.current = createStrategy(appId, strategyConfig);
+  }
+  (0, import_react2.useEffect)(() => {
+    return () => {
+      strategyRef.current?.destroy();
+      strategyRef.current = null;
+      managerRef.current?.destroy();
+      managerRef.current = null;
+    };
+  }, []);
+  const value = {
+    appId,
+    strategy: strategyRef.current,
+    iceServers,
+    networkManager: managerRef.current
+  };
+  return (0, import_react2.createElement)(MultiplayerContext.Provider, { value }, children);
+}
+
+// src/components/MultiplayerBridge.ts
+var import_react3 = require("react");
+function MultiplayerBridge({ children }) {
+  const ctx = (0, import_react3.useContext)(MultiplayerContext);
+  if (!ctx) return (0, import_react3.createElement)("group", null, children);
+  return (0, import_react3.createElement)(MultiplayerContext.Provider, { value: ctx }, children);
+}
+
+// src/hooks/useRoom.ts
+var import_react4 = require("react");
+
+// src/transport/webrtc/ice.ts
+var DEFAULT_STUN_SERVERS = [
+  { urls: "stun:stun.l.google.com:19302" },
+  { urls: "stun:stun1.l.google.com:19302" },
+  { urls: "stun:stun2.l.google.com:19302" },
+  { urls: "stun:stun.cloudflare.com:3478" }
+];
+function buildICEConfig(options) {
+  const servers = options?.iceServers && options.iceServers.length > 0 ? options.iceServers : DEFAULT_STUN_SERVERS;
+  return {
+    iceServers: servers,
+    iceCandidatePoolSize: 10,
+    iceTransportPolicy: options?.iceTransportPolicy ?? "all"
+  };
+}
+
+// src/transport/webrtc/peer.ts
+var PeerConnection = class {
+  constructor(peerId, config, events) {
+    this._channels = /* @__PURE__ */ new Map();
+    this._state = "connecting";
+    this._remoteDescriptionSet = false;
+    this._pendingCandidates = [];
+    this.peerId = peerId;
+    this._events = events;
+    this._connection = new RTCPeerConnection(config);
+    this._connection.onicecandidate = (e) => {
+      if (e.candidate) {
+        this._events.onIceCandidate(e.candidate);
+      }
+    };
+    this._connection.oniceconnectionstatechange = () => {
+      this._updateState();
+    };
+    this._connection.onconnectionstatechange = () => {
+      this._updateState();
+    };
+    this._connection.ondatachannel = (e) => {
+      const channel = e.channel;
+      this._channels.set(channel.label, channel);
+      this._events.onDataChannel(channel);
+    };
+  }
+  get state() {
+    return this._state;
+  }
+  get connection() {
+    return this._connection;
+  }
+  _updateState() {
+    const iceState = this._connection.iceConnectionState;
+    const connState = this._connection.connectionState;
+    let newState;
+    if (connState === "connected" || iceState === "connected") {
+      newState = "connected";
+    } else if (connState === "failed" || iceState === "failed") {
+      newState = "failed";
+    } else if (connState === "closed" || iceState === "closed" || iceState === "disconnected") {
+      newState = "disconnected";
+    } else {
+      newState = "connecting";
+    }
+    if (newState !== this._state) {
+      this._state = newState;
+      this._events.onStateChange(newState);
+    }
+  }
+  async createOffer() {
+    const offer = await this._connection.createOffer();
+    await this._connection.setLocalDescription(offer);
+    return offer;
+  }
+  async handleOffer(offer) {
+    await this._connection.setRemoteDescription(new RTCSessionDescription(offer));
+    this._remoteDescriptionSet = true;
+    await this._flushPendingCandidates();
+    const answer = await this._connection.createAnswer();
+    await this._connection.setLocalDescription(answer);
+    return answer;
+  }
+  async handleAnswer(answer) {
+    await this._connection.setRemoteDescription(new RTCSessionDescription(answer));
+    this._remoteDescriptionSet = true;
+    await this._flushPendingCandidates();
+  }
+  async addIceCandidate(candidate) {
+    if (!this._remoteDescriptionSet) {
+      this._pendingCandidates.push(candidate);
+      return;
+    }
+    try {
+      await this._connection.addIceCandidate(new RTCIceCandidate(candidate));
+    } catch {
+    }
+  }
+  async _flushPendingCandidates() {
+    const candidates = this._pendingCandidates;
+    this._pendingCandidates = [];
+    for (const c of candidates) {
+      try {
+        await this._connection.addIceCandidate(new RTCIceCandidate(c));
+      } catch {
+      }
+    }
+  }
+  createDataChannel(name, options) {
+    const existing = this._channels.get(name);
+    if (existing && existing.readyState !== "closed") {
+      return existing;
+    }
+    const dcOptions = {};
+    if (options?.reliable === false) {
+      dcOptions.ordered = options?.ordered ?? false;
+      dcOptions.maxRetransmits = options?.maxRetransmits ?? 0;
+    } else {
+      dcOptions.ordered = options?.ordered ?? true;
+    }
+    const channel = this._connection.createDataChannel(name, dcOptions);
+    this._channels.set(name, channel);
+    return channel;
+  }
+  getDataChannel(name) {
+    return this._channels.get(name);
+  }
+  close() {
+    for (const channel of this._channels.values()) {
+      try {
+        channel.close();
+      } catch {
+      }
+    }
+    this._channels.clear();
+    this._pendingCandidates = [];
+    this._remoteDescriptionSet = false;
+    try {
+      this._connection.close();
+    } catch {
+    }
+    this._state = "disconnected";
+  }
+};
+
+// src/transport/webrtc/WebRTCTransport.ts
+var ROOM_CONTROL_CHANNEL = "carver:room-control";
+function electHost(peerIds) {
+  return [...peerIds].sort()[0];
+}
+var WebRTCTransport = class {
+  /**
+   * @param strategy  Shared SignalingStrategy instance (managed by MultiplayerProvider)
+   * @param iceServers  Optional ICE servers (STUN + TURN). Defaults to public STUN.
+   * @param iceTransportPolicy  'all' (default) or 'relay' (force TURN only).
+   */
+  constructor(strategy, iceServers, iceTransportPolicy) {
+    this._peers = /* @__PURE__ */ new Map();
+    this._peerSet = /* @__PURE__ */ new Set();
+    this._hostId = "";
+    this._isHost = false;
+    this._callbacks = {
+      onPeerJoin: [],
+      onPeerLeave: [],
+      onPeerUpdated: [],
+      onHostChanged: []
+    };
+    this._roomUpdatedCallbacks = [];
+    this._channels = /* @__PURE__ */ new Map();
+    this._rateLimitConfig = { maxMessagesPerSecond: 60, windowMs: 1e3 };
+    this._rateLimitCounters = /* @__PURE__ */ new Map();
+    this._connected = false;
+    this._room = null;
+    this._playerMap = /* @__PURE__ */ new Map();
+    this._initialPeers = [];
+    this._strategyUnsubs = [];
+    this._strategy = strategy;
+    this._peerId = strategy.selfId;
+    this._iceConfig = buildICEConfig({ iceServers, iceTransportPolicy });
+  }
+  // ── CarverTransport getters ──
+  get peerId() {
+    return this._peerId;
+  }
+  get peers() {
+    return this._peerSet;
+  }
+  get hostId() {
+    return this._hostId;
+  }
+  get isHost() {
+    return this._isHost;
+  }
+  get room() {
+    return this._room ?? void 0;
+  }
+  get initialPlayers() {
+    return this._initialPeers;
+  }
+  // ── Event registration ──
+  onPeerJoin(cb) {
+    this._callbacks.onPeerJoin.push(cb);
+  }
+  onPeerLeave(cb) {
+    this._callbacks.onPeerLeave.push(cb);
+  }
+  onPeerUpdated(cb) {
+    this._callbacks.onPeerUpdated.push(cb);
+  }
+  onRoomUpdated(cb) {
+    this._roomUpdatedCallbacks.push(cb);
+  }
+  onHostChanged(cb) {
+    this._callbacks.onHostChanged.push(cb);
+  }
+  // ── Channel management ──
+  createChannel(name, options) {
+    const existing = this._channels.get(name);
+    if (existing) {
+      return {
+        send: (data, target) => this._sendOnChannel(name, data, target),
+        onReceive: (cb) => {
+          existing.receivers.push(cb);
+        },
+        close: () => {
+          this._channels.delete(name);
+        }
+      };
+    }
+    const state = {
+      name,
+      options: options ?? { reliable: true, ordered: true },
+      receivers: []
+    };
+    this._channels.set(name, state);
+    if (this._connected) {
+      for (const peer of this._peers.values()) {
+        this._createDataChannelOnPeer(peer, name, state.options);
+      }
+    }
+    return {
+      send: (data, target) => this._sendOnChannel(name, data, target),
+      onReceive: (cb) => {
+        state.receivers.push(cb);
+      },
+      close: () => {
+        this._channels.delete(name);
+      }
+    };
+  }
+  // ── Connect / Disconnect ──
+  async connect(roomId, config) {
+    if (config?.iceServers) {
+      this._iceConfig = buildICEConfig({
+        iceServers: config.iceServers,
+        iceTransportPolicy: config.iceTransportPolicy
+      });
+    }
+    this._setupRoomControlChannel();
+    this._preRegisterChannel("carver:events", { reliable: true, ordered: true });
+    this._preRegisterChannel("carver:snapshots", { reliable: false, ordered: false });
+    this._preRegisterChannel("carver:acks", { reliable: true, ordered: true });
+    this._preRegisterChannel("carver:inputs", { reliable: true, ordered: true });
+    this._preRegisterChannel("carver:network-state", { reliable: true, ordered: true });
+    this._strategyUnsubs.push(
+      this._strategy.onPeerDiscovered((peerId, meta) => {
+        this._onStrategyPeerDiscovered(peerId, meta);
+      })
+    );
+    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._strategyUnsubs.push(
+      this._strategy.onSignal((fromPeerId, data) => {
+        this._handleSignal(fromPeerId, data);
+      })
+    );
+    await this._strategy.joinRoom(roomId, {
+      displayName: config?.displayName,
+      ...config?.playerMetadata ?? {}
+    });
+    const selfPlayer = {
+      peerId: this._peerId,
+      displayName: config?.displayName ?? `Player-${this._peerId.slice(0, 4)}`,
+      isHost: false,
+      isSelf: true,
+      isReady: false,
+      isConnected: true,
+      metadata: config?.playerMetadata ?? {},
+      latencyMs: 0,
+      joinedAt: Date.now()
+    };
+    this._playerMap.set(this._peerId, selfPlayer);
+    this._electAndSetHost();
+    this._room = {
+      id: roomId,
+      name: roomId,
+      hostId: this._hostId,
+      playerCount: this._playerMap.size,
+      maxPlayers: config?.maxPlayers ?? 8,
+      isPrivate: false,
+      metadata: {},
+      createdAt: Date.now(),
+      state: "lobby"
+    };
+    this._initialPeers = Array.from(this._playerMap.values());
+    this._connected = true;
+  }
+  disconnect() {
+    this._connected = false;
+    for (const unsub of this._strategyUnsubs) unsub();
+    this._strategyUnsubs = [];
+    for (const peer of this._peers.values()) peer.close();
+    this._peers.clear();
+    this._peerSet.clear();
+    this._channels.clear();
+    this._rateLimitCounters.clear();
+    this._playerMap.clear();
+    this._strategy.leaveRoom().catch(() => {
+    });
+    this._hostId = "";
+    this._isHost = false;
+    this._room = null;
+  }
+  /** Expose strategy for lobby hooks */
+  get strategy() {
+    return this._strategy;
+  }
+  // ── Channel pre-registration ──
+  /**
+   * Register a channel name and options without creating data channels yet.
+   * When _connectToPeer runs, it iterates this._channels and creates data
+   * channels for every registered name in the initial WebRTC offer.
+   * Later, when EventSync/SnapshotSync call createChannel(), the idempotent
+   * check returns the pre-registered entry and they just attach receivers.
+   */
+  _preRegisterChannel(name, options) {
+    if (this._channels.has(name)) return;
+    this._channels.set(name, { name, options, receivers: [] });
+  }
+  // ── Room management (over WebRTC data channels) ──
+  setReady(ready) {
+    this._sendControlMessage({ type: "request-ready", ready });
+  }
+  setMetadata(metadata) {
+    this._sendControlMessage({ type: "request-metadata", metadata });
+  }
+  setRoomMetadata(metadata) {
+    if (!this._isHost) return;
+    this._sendControlMessage({ type: "request-room-metadata", metadata });
+  }
+  kick(peerId, reason) {
+    if (!this._isHost) return;
+    this._broadcastControlMessage({ type: "kick", peerId, reason });
+  }
+  transferHost(peerId) {
+    if (!this._isHost) return;
+    this._sendControlMessage({ type: "request-transfer-host", peerId });
+  }
+  setRoomState(state) {
+    if (!this._isHost) return;
+    this._sendControlMessage({ type: "request-room-state", state });
+  }
+  setMaxPlayers(n) {
+    if (!this._isHost) return;
+    this._sendControlMessage({ type: "request-max-players", maxPlayers: n });
+  }
+  lockRoom() {
+    if (!this._isHost) return;
+    this._sendControlMessage({ type: "request-lock" });
+  }
+  unlockRoom() {
+    if (!this._isHost) return;
+    this._sendControlMessage({ type: "request-unlock" });
+  }
+  /** No-op: lobby uses strategy.subscribeToLobby() directly */
+  requestRoomList() {
+  }
+  // ── Private: Strategy callbacks ──
+  _onStrategyPeerDiscovered(peerId, meta) {
+    this._connectToPeer(peerId);
+    this._peerSet.add(peerId);
+    const player = {
+      peerId,
+      displayName: meta.displayName ?? `Player-${peerId.slice(0, 4)}`,
+      isHost: false,
+      isSelf: false,
+      isReady: false,
+      isConnected: true,
+      metadata: meta,
+      latencyMs: 0,
+      joinedAt: Date.now()
+    };
+    this._playerMap.set(peerId, player);
+    this._electAndSetHost();
+    for (const cb of this._callbacks.onPeerJoin) cb(peerId);
+    for (const cb of this._callbacks.onPeerUpdated) cb(player);
+  }
+  // ── Private: Room control channel ──
+  _setupRoomControlChannel() {
+    const ch = this.createChannel(ROOM_CONTROL_CHANNEL, {
+      reliable: true,
+      ordered: true
+    });
+    ch.onReceive((msg, peerId) => {
+      this._handleControlMessage(msg, peerId);
+    });
+  }
+  _handleControlMessage(msg, fromPeerId) {
+    switch (msg.type) {
+      case "player-updated": {
+        this._playerMap.set(msg.player.peerId, msg.player);
+        for (const cb of this._callbacks.onPeerUpdated) cb(msg.player);
+        break;
+      }
+      case "room-updated": {
+        if (this._room) {
+          Object.assign(this._room, msg.room);
+          for (const cb of this._roomUpdatedCallbacks) cb(this._room);
+        }
+        break;
+      }
+      case "kick": {
+        if (msg.peerId === this._peerId) {
+          this.disconnect();
+        }
+        break;
+      }
+      case "host-changed": {
+        this._hostId = msg.newHostId;
+        this._isHost = msg.newHostId === this._peerId;
+        for (const cb of this._callbacks.onHostChanged) cb(msg.newHostId);
+        break;
+      }
+      case "sync-state": {
+        this._room = msg.room;
+        for (const p of msg.players) {
+          this._playerMap.set(p.peerId, { ...p, isSelf: p.peerId === this._peerId });
+          for (const cb of this._callbacks.onPeerUpdated) cb(p);
+        }
+        for (const cb of this._roomUpdatedCallbacks) cb(msg.room);
+        break;
+      }
+      // Host processes requests from peers
+      case "request-ready": {
+        if (!this._isHost) break;
+        const p = this._playerMap.get(fromPeerId);
+        if (p) {
+          p.isReady = msg.ready;
+          this._broadcastControlMessage({ type: "player-updated", player: p });
+        }
+        break;
+      }
+      case "request-metadata": {
+        if (!this._isHost) break;
+        const pm = this._playerMap.get(fromPeerId);
+        if (pm) {
+          pm.metadata = { ...pm.metadata, ...msg.metadata };
+          this._broadcastControlMessage({ type: "player-updated", player: pm });
+        }
+        break;
+      }
+      case "request-room-metadata": {
+        if (!this._isHost || !this._room) break;
+        this._room.metadata = { ...this._room.metadata, ...msg.metadata };
+        this._broadcastControlMessage({ type: "room-updated", room: this._room });
+        break;
+      }
+      case "request-room-state": {
+        if (!this._isHost || !this._room) break;
+        this._room.state = msg.state;
+        this._broadcastControlMessage({ type: "room-updated", room: this._room });
+        break;
+      }
+      case "request-max-players": {
+        if (!this._isHost || !this._room) break;
+        this._room.maxPlayers = msg.maxPlayers;
+        this._broadcastControlMessage({ type: "room-updated", room: this._room });
+        break;
+      }
+      case "request-lock": {
+        if (!this._isHost || !this._room) break;
+        this._room.locked = true;
+        this._broadcastControlMessage({ type: "room-updated", room: this._room });
+        break;
+      }
+      case "request-unlock": {
+        if (!this._isHost || !this._room) break;
+        this._room.locked = false;
+        this._broadcastControlMessage({ type: "room-updated", room: this._room });
+        break;
+      }
+      case "request-transfer-host": {
+        if (!this._isHost) break;
+        this._hostId = msg.peerId;
+        this._isHost = false;
+        this._broadcastControlMessage({ type: "host-changed", newHostId: msg.peerId });
+        break;
+      }
+    }
+  }
+  _sendControlMessage(msg) {
+    if (this._isHost && msg.type.startsWith("request-")) {
+      this._handleControlMessage(msg, this._peerId);
+      return;
+    }
+    if (this._hostId && this._hostId !== this._peerId) {
+      this._sendOnChannel(ROOM_CONTROL_CHANNEL, msg, this._hostId);
+    }
+  }
+  _broadcastControlMessage(msg) {
+    this._sendOnChannel(ROOM_CONTROL_CHANNEL, msg);
+    this._handleControlMessage(msg, this._peerId);
+  }
+  // ── Private: Host election ──
+  _electAndSetHost() {
+    const allIds = [this._peerId, ...this._peerSet];
+    const newHostId = electHost(allIds);
+    const changed = newHostId !== this._hostId;
+    this._hostId = newHostId;
+    this._isHost = newHostId === this._peerId;
+    for (const [id, p] of this._playerMap) {
+      p.isHost = id === newHostId;
+    }
+    if (this._room) {
+      this._room.hostId = newHostId;
+      this._room.playerCount = this._playerMap.size;
+    }
+    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" && this._isHost && this._room) {
+          const syncMsg = {
+            type: "sync-state",
+            room: this._room,
+            players: Array.from(this._playerMap.values())
+          };
+          setTimeout(() => {
+            this._sendOnChannel(ROOM_CONTROL_CHANNEL, syncMsg, peerId);
+          }, 100);
+        }
+        if (state === "failed" || state === "disconnected") {
+          this._removePeer(peerId);
+          this._playerMap.delete(peerId);
+          this._electAndSetHost();
+          for (const cb of this._callbacks.onPeerLeave) cb(peerId);
+        }
+      },
+      onDataChannel: (channel) => {
+        this._setupDataChannelReceiver(channel, peerId);
+      },
+      onIceCandidate: (candidate) => {
+        this._strategy.signal(peerId, { type: "ice-candidate", candidate: candidate.toJSON() });
+      }
+    });
+    this._peers.set(peerId, peer);
+    this._peerSet.add(peerId);
+    if (this._peerId < peerId) {
+      for (const [name, state] of this._channels) {
+        this._createDataChannelOnPeer(peer, name, state.options);
+      }
+      peer.createOffer().then((offer) => {
+        this._strategy.signal(peerId, { type: "offer", sdp: offer });
+      });
+    }
+  }
+  async _handleSignal(peerId, data) {
+    try {
+      const signal = data;
+      let peer = this._peers.get(peerId);
+      if (signal.type === "offer") {
+        if (!peer) {
+          this._connectToPeer(peerId);
+          peer = this._peers.get(peerId);
+        }
+        const answer = await peer.handleOffer(signal.sdp);
+        this._strategy.signal(peerId, { type: "answer", sdp: answer });
+      } else if (signal.type === "answer" && peer) {
+        await peer.handleAnswer(signal.sdp);
+      } else if (signal.type === "ice-candidate" && peer) {
+        await peer.addIceCandidate(signal.candidate);
+      }
+    } catch (err) {
+      if (typeof console !== "undefined") {
+        console.error("[CarverJS] Signal handling failed:", err);
+      }
+    }
+  }
+  // ── Private: Data channel helpers ──
+  _createDataChannelOnPeer(peer, name, options) {
+    const channel = peer.createDataChannel(name, options);
+    this._setupDataChannelReceiver(channel, peer.peerId);
+  }
+  _setupDataChannelReceiver(dataChannel, peerId) {
+    const channelName = dataChannel.label;
+    dataChannel.onmessage = (event) => {
+      if (!this._checkRateLimit(peerId)) return;
+      const channelState = this._channels.get(channelName);
+      if (!channelState) return;
+      try {
+        const data = typeof event.data === "string" ? JSON.parse(event.data) : event.data;
+        for (const receiver of channelState.receivers) receiver(data, peerId);
+      } catch {
+      }
+    };
+  }
+  _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 (ch?.readyState === "open") {
+        try {
+          ch.send(serialized);
+        } catch {
+        }
+      }
+    }
+  }
+  _removePeer(peerId) {
+    const peer = this._peers.get(peerId);
+    if (peer) {
+      peer.close();
+      this._peers.delete(peerId);
+    }
+    this._peerSet.delete(peerId);
+    this._rateLimitCounters.delete(peerId);
+  }
+  _checkRateLimit(peerId) {
+    const now = Date.now();
+    let c = this._rateLimitCounters.get(peerId);
+    if (!c || now >= c.resetAt) {
+      c = { count: 0, resetAt: now + this._rateLimitConfig.windowMs };
+      this._rateLimitCounters.set(peerId, c);
+    }
+    c.count++;
+    return c.count <= this._rateLimitConfig.maxMessagesPerSecond;
+  }
+};
+
+// src/hooks/useRoom.ts
+function useRoom(roomId, options) {
+  const { strategy, iceServers, networkManager } = useMultiplayerContext();
+  const [connectionState, setConnectionState] = (0, import_react4.useState)("disconnected");
+  const [isHost, setIsHost] = (0, import_react4.useState)(false);
+  const [hostId, setHostId] = (0, import_react4.useState)(null);
+  const [selfId, setSelfId] = (0, import_react4.useState)(null);
+  const [currentRoomId, setCurrentRoomId] = (0, import_react4.useState)(null);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const [transport, setTransport] = (0, import_react4.useState)(null);
+  const [room, setRoom] = (0, import_react4.useState)(null);
+  const reconnectAttemptsRef = (0, import_react4.useRef)(0);
+  const maxReconnectAttempts = options?.reconnectAttempts ?? 3;
+  const optionsRef = (0, import_react4.useRef)(options);
+  optionsRef.current = options;
+  const createTransport = (0, import_react4.useCallback)(() => {
+    const opt = optionsRef.current;
+    if (opt?.transport && typeof opt.transport === "object" && "connect" in opt.transport) {
+      return opt.transport;
+    }
+    const servers = opt?.iceServers ?? iceServers;
+    const policy = opt?.privacy === "relay" ? "relay" : "all";
+    return new WebRTCTransport(strategy, servers, policy);
+  }, [strategy, iceServers]);
+  const transportRef = (0, import_react4.useRef)(null);
+  const doJoin = (0, import_react4.useCallback)(async (targetRoomId, joinOptions) => {
+    if (transportRef.current) {
+      transportRef.current.disconnect();
+      transportRef.current = null;
+    }
+    const t = createTransport();
+    transportRef.current = t;
+    try {
+      setError(null);
+      setConnectionState("connecting");
+      networkManager.setConnectionState("connecting");
+      setTransport(t);
+      networkManager.setTransport(t);
+      t.onPeerJoin(() => {
+      });
+      t.onPeerLeave(() => {
+      });
+      t.onHostChanged((newHostId) => {
+        setHostId(newHostId);
+        setIsHost(t.peerId === newHostId);
+        optionsRef.current?.onHostMigration?.(newHostId);
+      });
+      if ("onRoomUpdated" in t && typeof t.onRoomUpdated === "function") {
+        t.onRoomUpdated((updatedRoom) => {
+          networkManager.setRoom(updatedRoom);
+        });
+      }
+      await t.connect(targetRoomId, {
+        displayName: optionsRef.current?.displayName,
+        playerMetadata: optionsRef.current?.playerMetadata,
+        password: joinOptions?.password ?? optionsRef.current?.password,
+        iceServers: optionsRef.current?.iceServers,
+        iceTransportPolicy: optionsRef.current?.privacy === "relay" ? "relay" : "all"
+      });
+      if (transportRef.current !== t) return;
+      setCurrentRoomId(targetRoomId);
+      setSelfId(t.peerId);
+      setHostId(t.hostId);
+      setIsHost(t.isHost);
+      setConnectionState("connected");
+      networkManager.setConnectionState("connected");
+      if (t.room) {
+        networkManager.setRoom(t.room);
+      }
+      if (t.initialPlayers) {
+        const players = t.initialPlayers.map((p) => ({
+          ...p,
+          isSelf: p.peerId === t.peerId
+        }));
+        networkManager.setPlayers(players);
+      }
+      reconnectAttemptsRef.current = 0;
+      optionsRef.current?.onConnected?.();
+    } catch (err) {
+      if (transportRef.current !== t) return;
+      const carverError = {
+        code: "CONNECTION_FAILED",
+        message: err instanceof Error ? err.message : "Connection failed",
+        recoverable: reconnectAttemptsRef.current < maxReconnectAttempts
+      };
+      setError(carverError);
+      networkManager.emitError(carverError);
+      setConnectionState("disconnected");
+      networkManager.setConnectionState("disconnected");
+      optionsRef.current?.onError?.(carverError);
+    }
+  }, [createTransport, networkManager, maxReconnectAttempts]);
+  const leave = (0, import_react4.useCallback)(() => {
+    if (transportRef.current) {
+      transportRef.current.disconnect();
+      transportRef.current = null;
+    }
+    setTransport(null);
+    setConnectionState("disconnected");
+    setCurrentRoomId(null);
+    setSelfId(null);
+    setHostId(null);
+    setIsHost(false);
+    setError(null);
+    networkManager.setConnectionState("disconnected");
+    optionsRef.current?.onDisconnected?.("user_left");
+  }, [networkManager]);
+  const setReady = (0, import_react4.useCallback)((ready) => {
+    transport?.setReady?.(ready);
+    const selfPlayer = networkManager.players.get(transport?.peerId ?? "");
+    if (selfPlayer) {
+      networkManager.updatePlayer({ ...selfPlayer, isReady: ready });
+    }
+  }, [transport, networkManager]);
+  const setMetadata = (0, import_react4.useCallback)((meta) => {
+    transport?.setMetadata?.(meta);
+  }, [transport]);
+  const setRoomMetadata = (0, import_react4.useCallback)((meta) => {
+    transport?.setRoomMetadata?.(meta);
+  }, [transport]);
+  (0, import_react4.useEffect)(() => {
+    if (roomId) {
+      doJoin(roomId);
+    }
+    return () => {
+      if (transportRef.current) {
+        transportRef.current.disconnect();
+        transportRef.current = null;
+      }
+    };
+  }, [roomId, doJoin]);
+  (0, import_react4.useEffect)(() => {
+    const unsub = networkManager.onRoomChange(() => {
+      setRoom(networkManager.room);
+    });
+    setRoom(networkManager.room);
+    return unsub;
+  }, [networkManager]);
+  return {
+    roomId: currentRoomId,
+    connectionState,
+    isHost,
+    hostId,
+    selfId,
+    room,
+    error,
+    join: doJoin,
+    leave,
+    setReady,
+    setMetadata,
+    setRoomMetadata,
+    transport
+  };
+}
+
+// src/hooks/useLobby.ts
+var import_react5 = require("react");
+function announcementToRoom(ann) {
+  return {
+    id: ann.roomId,
+    name: ann.name,
+    hostId: ann.hostId,
+    playerCount: ann.playerCount,
+    maxPlayers: ann.maxPlayers,
+    gameMode: ann.gameMode,
+    isPrivate: ann.isPrivate,
+    metadata: ann.metadata,
+    createdAt: ann.createdAt,
+    state: "lobby"
+  };
+}
+function useLobby(options) {
+  const { strategy } = useMultiplayerContext();
+  const [rooms, setRooms] = (0, import_react5.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react5.useState)(true);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const optionsRef = (0, import_react5.useRef)(options);
+  optionsRef.current = options;
+  const filterRooms = (0, import_react5.useCallback)((roomList) => {
+    const filter = optionsRef.current?.filter;
+    if (!filter) return roomList;
+    return roomList.filter((room) => {
+      if (filter.maxPlayers !== void 0 && room.maxPlayers > filter.maxPlayers) return false;
+      if (filter.gameMode !== void 0 && room.gameMode !== filter.gameMode) return false;
+      if (filter.hasPassword !== void 0 && room.isPrivate !== filter.hasPassword) return false;
+      return true;
+    });
+  }, []);
+  (0, import_react5.useEffect)(() => {
+    setIsLoading(true);
+    setError(null);
+    const unsub = strategy.subscribeToLobby((announcements) => {
+      const converted = announcements.map(announcementToRoom);
+      setRooms(filterRooms(converted));
+      setIsLoading(false);
+    });
+    const timeout = setTimeout(() => setIsLoading(false), 3e3);
+    return () => {
+      unsub();
+      clearTimeout(timeout);
+    };
+  }, [strategy, filterRooms]);
+  const refresh = (0, import_react5.useCallback)(() => {
+    setIsLoading(true);
+    setTimeout(() => setIsLoading(false), 1e3);
+  }, []);
+  const createRoom = (0, import_react5.useCallback)(async (config) => {
+    const roomId = `${config.name.toLowerCase().replace(/\s+/g, "-")}-${Date.now().toString(36)}`;
+    const announcement = {
+      roomId,
+      name: config.name,
+      hostId: strategy.selfId,
+      playerCount: 0,
+      maxPlayers: config.maxPlayers ?? 8,
+      gameMode: config.metadata?.gameMode,
+      isPrivate: config.isPrivate ?? false,
+      metadata: config.metadata ?? {},
+      createdAt: Date.now(),
+      lastSeen: Date.now()
+    };
+    strategy.announceRoom(announcement);
+    return roomId;
+  }, [strategy]);
+  return {
+    rooms,
+    isLoading,
+    error,
+    refresh,
+    createRoom
+  };
+}
+
+// src/hooks/usePlayers.ts
+var import_react6 = require("react");
+function usePlayers() {
+  const { networkManager } = useMultiplayerContext();
+  const [players, setPlayers] = (0, import_react6.useState)([]);
+  const [, setVersion] = (0, import_react6.useState)(0);
+  (0, import_react6.useEffect)(() => {
+    const unsubscribe = networkManager.onPlayersChange(() => {
+      setPlayers(Array.from(networkManager.players.values()));
+      setVersion((v) => v + 1);
+    });
+    setPlayers(Array.from(networkManager.players.values()));
+    return unsubscribe;
+  }, [networkManager]);
+  const self = players.find((p) => p.isSelf) ?? null;
+  const host = players.find((p) => p.isHost) ?? null;
+  const allReady = players.length > 0 && players.every((p) => p.isReady);
+  const getPlayer = (0, import_react6.useCallback)(
+    (peerId) => players.find((p) => p.peerId === peerId),
+    [players]
+  );
+  return {
+    players,
+    self,
+    host,
+    count: players.length,
+    allReady,
+    getPlayer
+  };
+}
+
+// src/hooks/useHost.ts
+var import_react7 = require("react");
+function useHost() {
+  const { networkManager } = useMultiplayerContext();
+  const getTransport = (0, import_react7.useCallback)(() => {
+    const transport = networkManager.transport;
+    if (!transport || !networkManager.isHost) return null;
+    return transport;
+  }, [networkManager]);
+  const kick = (0, import_react7.useCallback)((peerId, reason) => {
+    getTransport()?.kick?.(peerId, reason);
+  }, [getTransport]);
+  const transferHost = (0, import_react7.useCallback)((peerId) => {
+    getTransport()?.transferHost?.(peerId);
+  }, [getTransport]);
+  const setRoomState = (0, import_react7.useCallback)((state) => {
+    getTransport()?.setRoomState?.(state);
+  }, [getTransport]);
+  const setMaxPlayers = (0, import_react7.useCallback)((n) => {
+    getTransport()?.setMaxPlayers?.(n);
+  }, [getTransport]);
+  const lockRoom = (0, import_react7.useCallback)(() => {
+    getTransport()?.lockRoom?.();
+  }, [getTransport]);
+  const unlockRoom = (0, import_react7.useCallback)(() => {
+    getTransport()?.unlockRoom?.();
+  }, [getTransport]);
+  return {
+    kick,
+    transferHost,
+    setRoomState,
+    setMaxPlayers,
+    lockRoom,
+    unlockRoom
+  };
+}
+
+// src/hooks/useMultiplayer.ts
+var import_react8 = require("react");
+var import_fiber = require("@react-three/fiber");
+var import_systems = require("@carverjs/core/systems");
+
+// 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_msgpackr2 = 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_msgpackr2.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_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);
+  }
+};
+
+// src/core/NetworkSimulator.ts
+var NetworkSimulator = class {
+  constructor(options) {
+    this.sentCount = 0;
+    this.droppedCount = 0;
+    this.latencySum = 0;
+    // running sum of applied latencies
+    /** Active timeout handles so we can cancel them on destroy() */
+    this.pending = /* @__PURE__ */ new Set();
+    const opts = options ?? {};
+    this.latencyMs = opts.latencyMs ?? 0;
+    this.packetLoss = opts.packetLoss ?? 0;
+    this.jitterMs = opts.jitterMs ?? 0;
+  }
+  /* ---- public API ---- */
+  /** Update simulation parameters at runtime. */
+  setOptions(options) {
+    if (options.latencyMs !== void 0) this.latencyMs = options.latencyMs;
+    if (options.packetLoss !== void 0) this.packetLoss = options.packetLoss;
+    if (options.jitterMs !== void 0) this.jitterMs = options.jitterMs;
+  }
+  /**
+   * Wrap an existing send function so that every call goes through the
+   * simulated network conditions (latency, jitter, packet loss).
+   */
+  wrapSend(originalSend) {
+    return (data, target) => {
+      if (Math.random() < this.packetLoss) {
+        this.droppedCount++;
+        return;
+      }
+      this.sentCount++;
+      const jitter = this.jitterMs > 0 ? Math.random() * 2 * this.jitterMs - this.jitterMs : 0;
+      const delay = Math.max(0, this.latencyMs + jitter);
+      this.latencySum += delay;
+      if (delay === 0) {
+        originalSend(data, target);
+      } else {
+        const handle = setTimeout(() => {
+          this.pending.delete(handle);
+          originalSend(data, target);
+        }, delay);
+        this.pending.add(handle);
+      }
+    };
+  }
+  /** Current statistics snapshot. */
+  get stats() {
+    return {
+      sentCount: this.sentCount,
+      droppedCount: this.droppedCount,
+      avgLatencyMs: this.sentCount > 0 ? this.latencySum / this.sentCount : 0
+    };
+  }
+  /** Cancel all pending delayed sends and clean up. */
+  destroy() {
+    for (const handle of this.pending) {
+      clearTimeout(handle);
+    }
+    this.pending.clear();
+  }
+};
+
+// src/hooks/useMultiplayer.ts
+var Z_THRESHOLD = 0.01;
+function detect2D(actors) {
+  for (const [, ref] of actors) {
+    if (Math.abs(ref.object3D.position.z) > Z_THRESHOLD) return false;
+  }
+  return true;
+}
+function readEntityState2D(ref) {
+  const pos = ref.object3D.position;
+  const rot = ref.object3D.rotation;
+  const rb = ref.rigidBody;
+  let vx = 0;
+  let vy = 0;
+  let va = 0;
+  if (rb) {
+    try {
+      const lv = rb.linvel();
+      vx = lv.x;
+      vy = lv.y;
+    } catch {
+    }
+    try {
+      const av = rb.angvel();
+      va = typeof av === "number" ? av : av?.z ?? 0;
+    } catch {
+    }
+  }
+  const nc = ref.userData.networked;
+  const custom = nc?.custom;
+  return {
+    id: ref.id,
+    x: pos.x,
+    y: pos.y,
+    a: rot.z,
+    vx,
+    vy,
+    va,
+    ...custom ? { c: custom } : {}
+  };
+}
+function readEntityState3D(ref) {
+  const pos = ref.object3D.position;
+  const quat = ref.object3D.quaternion;
+  const rb = ref.rigidBody;
+  let vx = 0;
+  let vy = 0;
+  let vz = 0;
+  let wx = 0;
+  let wy = 0;
+  let wz = 0;
+  if (rb) {
+    try {
+      const lv = rb.linvel();
+      vx = lv.x;
+      vy = lv.y;
+      vz = lv.z ?? 0;
+    } catch {
+    }
+    try {
+      const av = rb.angvel();
+      wx = av.x ?? 0;
+      wy = av.y ?? 0;
+      wz = av.z ?? 0;
+    } catch {
+    }
+  }
+  const nc = ref.userData.networked;
+  const custom = nc?.custom;
+  return {
+    id: ref.id,
+    x: pos.x,
+    y: pos.y,
+    z: pos.z,
+    qx: quat.x,
+    qy: quat.y,
+    qz: quat.z,
+    qw: quat.w,
+    vx,
+    vy,
+    vz,
+    wx,
+    wy,
+    wz,
+    ...custom ? { c: custom } : {}
+  };
+}
+function buildEntityMap(actors, is2D) {
+  const entities = /* @__PURE__ */ new Map();
+  for (const [id, ref] of actors) {
+    const nc = ref.userData.networked;
+    if (nc && nc.sync === false) continue;
+    entities.set(id, is2D ? readEntityState2D(ref) : readEntityState3D(ref));
+  }
+  return entities;
+}
+function applyState2D(ref, state) {
+  ref.object3D.position.set(state.x, state.y, 0);
+  ref.object3D.rotation.z = state.a;
+  if (ref.rigidBody) {
+    try {
+      if (typeof ref.rigidBody.setTranslation === "function") {
+        ref.rigidBody.setTranslation({ x: state.x, y: state.y }, true);
+      }
+      if (typeof ref.rigidBody.setRotation === "function") {
+        ref.rigidBody.setRotation(state.a, true);
+      }
+    } catch {
+    }
+  }
+}
+function applyState3D(ref, state) {
+  ref.object3D.position.set(state.x, state.y, state.z);
+  ref.object3D.quaternion.set(state.qx, state.qy, state.qz, state.qw);
+  if (ref.rigidBody) {
+    try {
+      if (typeof ref.rigidBody.setTranslation === "function") {
+        ref.rigidBody.setTranslation({ x: state.x, y: state.y, z: state.z }, true);
+      }
+      if (typeof ref.rigidBody.setRotation === "function") {
+        ref.rigidBody.setRotation(
+          { x: state.qx, y: state.qy, z: state.qz, w: state.qw },
+          true
+        );
+      }
+    } catch {
+    }
+  }
+}
+function applyEntityState(ref, state, is2D) {
+  if (is2D) {
+    applyState2D(ref, state);
+  } else {
+    applyState3D(ref, state);
+  }
+}
+function applyStatesToActors(states, registry, is2D) {
+  for (const [id, state] of states) {
+    if (state.c && state.c.__removed) continue;
+    const ref = registry.get(id);
+    if (!ref) continue;
+    applyEntityState(ref, state, is2D);
+  }
+}
+function useMultiplayer(options = {}) {
+  const { networkManager } = useMultiplayerContext();
+  const mode = options.mode ?? networkManager.syncMode;
+  const eventSyncRef = (0, import_react8.useRef)(null);
+  const snapshotSyncRef = (0, import_react8.useRef)(null);
+  const predictionSyncRef = (0, import_react8.useRef)(null);
+  const networkSimulatorRef = (0, import_react8.useRef)(null);
+  const is2DRef = (0, import_react8.useRef)(null);
+  const [isActive, setIsActive] = (0, import_react8.useState)(false);
+  const [networkQuality, setNetworkQuality] = (0, import_react8.useState)("good");
+  const [tick, setTick] = (0, import_react8.useState)(0);
+  const [serverTick, setServerTick] = (0, import_react8.useState)(0);
+  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 buildSnapshotOpts = (0, import_react8.useCallback)(() => {
+    return {
+      broadcastRate: options.broadcastRate,
+      keyframeInterval: options.keyframeInterval,
+      bufferSize: options.interpolation?.bufferSize,
+      interpolationMethod: options.interpolation?.method,
+      extrapolateMs: options.interpolation?.extrapolateMs,
+      is2D: is2DRef.current ?? true
+    };
+  }, [
+    options.broadcastRate,
+    options.keyframeInterval,
+    options.interpolation?.bufferSize,
+    options.interpolation?.method,
+    options.interpolation?.extrapolateMs
+  ]);
+  (0, import_react8.useEffect)(() => {
+    const transport = networkManager.transport;
+    if (!transport) return;
+    const debugOpts = options.debug;
+    let simulator = null;
+    if (debugOpts?.simulatedLatencyMs || debugOpts?.simulatedPacketLoss) {
+      simulator = new NetworkSimulator({
+        latencyMs: debugOpts.simulatedLatencyMs,
+        packetLoss: debugOpts.simulatedPacketLoss
+      });
+      networkSimulatorRef.current = simulator;
+      const origCreateChannel = transport.createChannel.bind(transport);
+      transport.createChannel = (name, channelOpts) => {
+        const ch = origCreateChannel(name, channelOpts);
+        const wrappedSend = simulator.wrapSend(ch.send.bind(ch));
+        return { ...ch, send: wrappedSend };
+      };
+    }
+    eventSyncRef.current = new EventSync(transport);
+    if (mode === "snapshot" || mode === "prediction") {
+      snapshotSyncRef.current = new SnapshotSync(
+        transport,
+        networkManager.codec,
+        networkManager.snapshotBuffer,
+        buildSnapshotOpts()
+      );
+    }
+    if (mode === "prediction") {
+      predictionSyncRef.current = new PredictionSync(
+        transport,
+        networkManager.codec,
+        networkManager.tickKeeper,
+        options.prediction
+      );
+      if (options.onPhysicsStep) {
+        predictionSyncRef.current.setPhysicsStep(options.onPhysicsStep);
+      }
+    }
+    wasHostRef.current = networkManager.isHost;
+    setIsActive(true);
+    const unsubHostChanged = (() => {
+      const onHostChanged = (newHostId) => {
+        const amNewHost = newHostId === transport.peerId;
+        const wasPreviouslyHost = wasHostRef.current;
+        wasHostRef.current = amNewHost;
+        if (amNewHost && !wasPreviouslyHost) {
+          snapshotSyncRef.current?.promoteToHost(buildSnapshotOpts());
+        } else if (!amNewHost && wasPreviouslyHost) {
+          snapshotSyncRef.current?.demoteToClient(buildSnapshotOpts());
+        }
+      };
+      transport.onHostChanged(onHostChanged);
+      return () => {
+      };
+    })();
+    return () => {
+      unsubHostChanged();
+      eventSyncRef.current?.destroy();
+      snapshotSyncRef.current?.destroy();
+      predictionSyncRef.current?.destroy();
+      networkSimulatorRef.current?.destroy();
+      eventSyncRef.current = null;
+      snapshotSyncRef.current = null;
+      predictionSyncRef.current = null;
+      networkSimulatorRef.current = null;
+      setIsActive(false);
+    };
+  }, [networkManager, mode, buildSnapshotOpts, options.prediction, options.onPhysicsStep, options.debug]);
+  (0, import_react8.useEffect)(() => {
+    const unsub = networkManager.onConnectionStateChange(() => {
+      setNetworkQuality(networkManager.networkQuality);
+    });
+    return unsub;
+  }, [networkManager]);
+  (0, import_fiber.useFrame)((_state, delta) => {
+    const transport = networkManager.transport;
+    if (!transport) return;
+    const tickKeeper = networkManager.tickKeeper;
+    const isHost = networkManager.isHost;
+    if (is2DRef.current === null) {
+      const networked = actorRegistry.current.getNetworked();
+      if (networked.size > 0) {
+        is2DRef.current = detect2D(networked);
+      }
+    }
+    const is2D = is2DRef.current ?? true;
+    if (mode === "events") return;
+    const ticksThisFrame = tickKeeper.update(delta);
+    for (let i = 0; i < ticksThisFrame; i++) {
+      const currentTick = tickKeeper.tick - (ticksThisFrame - 1 - i);
+      if (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);
+        }
+      }
+    }
+    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 (ticksThisFrame > 0) {
+      const newTick = tickKeeper.tick;
+      const newServerTick = tickKeeper.serverTick;
+      const newDrift = tickKeeper.drift;
+      const newQuality = networkManager.networkQuality;
+      setTick((prev) => prev !== newTick ? newTick : prev);
+      setServerTick((prev) => prev !== newServerTick ? newServerTick : prev);
+      setDrift((prev) => prev !== newDrift ? newDrift : prev);
+      setNetworkQuality((prev) => prev !== newQuality ? newQuality : prev);
+    }
+  }, -55);
+  return {
+    isActive,
+    networkQuality,
+    tick,
+    serverTick,
+    drift,
+    syncEngine: mode
+  };
+}
+
+// src/hooks/useNetworkEvents.ts
+var import_react9 = require("react");
+function useNetworkEvents(options) {
+  const { networkManager } = useMultiplayerContext();
+  const eventSyncRef = (0, import_react9.useRef)(null);
+  const pendingRef = (0, import_react9.useRef)([]);
+  const drainedUnsubsRef = (0, import_react9.useRef)([]);
+  (0, import_react9.useEffect)(() => {
+    const transport = networkManager.transport;
+    if (!transport) return;
+    const eventSync = new EventSync(transport, {
+      hostValidation: options?.hostValidation
+    });
+    eventSyncRef.current = eventSync;
+    const unsubs = [];
+    for (const entry of pendingRef.current) {
+      const unsub = eventSync.onEvent(entry.type, entry.callback);
+      entry.unsub = unsub;
+      unsubs.push(unsub);
+    }
+    pendingRef.current = [];
+    drainedUnsubsRef.current = unsubs;
+    return () => {
+      for (const unsub of drainedUnsubsRef.current) {
+        unsub();
+      }
+      drainedUnsubsRef.current = [];
+      eventSync.destroy();
+      eventSyncRef.current = null;
+    };
+  }, [networkManager.transport, options?.hostValidation]);
+  const sendEvent = (0, import_react9.useCallback)((type, payload, target) => {
+    eventSyncRef.current?.sendEvent(type, payload, target);
+  }, []);
+  const broadcast = (0, import_react9.useCallback)((type, payload) => {
+    eventSyncRef.current?.broadcast(type, payload);
+  }, []);
+  const onEvent = (0, import_react9.useCallback)((type, callback) => {
+    const castCallback = callback;
+    if (eventSyncRef.current) {
+      return eventSyncRef.current.onEvent(type, castCallback);
+    }
+    const entry = { type, callback: castCallback, unsub: null };
+    pendingRef.current.push(entry);
+    return () => {
+      if (entry.unsub) {
+        entry.unsub();
+        drainedUnsubsRef.current = drainedUnsubsRef.current.filter((u) => u !== entry.unsub);
+      } else {
+        pendingRef.current = pendingRef.current.filter((e) => e !== entry);
+      }
+    };
+  }, []);
+  return { sendEvent, broadcast, onEvent };
+}
+
+// src/hooks/useNetworkState.ts
+var import_react10 = require("react");
+var CHANNEL_NAME = "carver:network-state";
+function useNetworkState() {
+  const { networkManager } = useMultiplayerContext();
+  const [entities, setEntities] = (0, import_react10.useState)(
+    () => /* @__PURE__ */ new Map()
+  );
+  const entitiesRef = (0, import_react10.useRef)(entities);
+  entitiesRef.current = entities;
+  const channelRef = (0, import_react10.useRef)(null);
+  const replaceEntities = (0, import_react10.useCallback)(
+    (updater) => {
+      setEntities((prev) => {
+        const next = updater(prev);
+        entitiesRef.current = next;
+        return next;
+      });
+    },
+    []
+  );
+  const applySpawn = (0, import_react10.useCallback)(
+    (id, state) => {
+      replaceEntities((prev) => {
+        const next = new Map(prev);
+        next.set(id, state);
+        return next;
+      });
+    },
+    [replaceEntities]
+  );
+  const applyDespawn = (0, import_react10.useCallback)(
+    (id) => {
+      replaceEntities((prev) => {
+        if (!prev.has(id)) return prev;
+        const next = new Map(prev);
+        next.delete(id);
+        return next;
+      });
+    },
+    [replaceEntities]
+  );
+  (0, import_react10.useEffect)(() => {
+    const transport = networkManager.transport;
+    if (!transport) return;
+    const channel = transport.createChannel(CHANNEL_NAME, {
+      reliable: true,
+      ordered: true
+    });
+    channelRef.current = channel;
+    channel.onReceive((msg, _peerId) => {
+      switch (msg.action) {
+        // --- Spawn broadcast (sent by host to everyone) ---
+        case "spawn": {
+          if (msg.state) {
+            applySpawn(msg.id, msg.state);
+          }
+          break;
+        }
+        // --- Despawn broadcast (sent by host to everyone) ---
+        case "despawn": {
+          applyDespawn(msg.id);
+          break;
+        }
+        // --- Request-spawn (client -> host only) ---
+        case "request-spawn": {
+          if (!transport.isHost) break;
+          if (entitiesRef.current.has(msg.id)) break;
+          const config = msg.state ?? {};
+          const newState = {
+            id: msg.id,
+            x: 0,
+            y: 0,
+            a: 0,
+            vx: 0,
+            vy: 0,
+            va: 0,
+            ...config,
+            // Ensure id is authoritative.
+            ...config.id !== void 0 ? {} : {}
+          };
+          newState.id = msg.id;
+          applySpawn(msg.id, newState);
+          channel.send({ action: "spawn", id: msg.id, state: newState });
+          break;
+        }
+      }
+    });
+    return () => {
+      channel.close();
+      channelRef.current = null;
+    };
+  }, [networkManager.transport, applySpawn, applyDespawn]);
+  const spawn = (0, import_react10.useCallback)(
+    (id, initialState) => {
+      const transport = networkManager.transport;
+      if (!transport) {
+        console.warn("[useNetworkState] spawn called before transport is ready.");
+        return;
+      }
+      if (!transport.isHost) {
+        console.warn(
+          "[useNetworkState] spawn is host-only. Use requestSpawn() from a client."
+        );
+        return;
+      }
+      if (entitiesRef.current.has(id)) {
+        console.warn(
+          `[useNetworkState] entity "${id}" already exists. Ignoring spawn.`
+        );
+        return;
+      }
+      const state = { ...initialState, id };
+      applySpawn(id, state);
+      channelRef.current?.send({ action: "spawn", id, state });
+    },
+    [networkManager, applySpawn]
+  );
+  const despawn = (0, import_react10.useCallback)(
+    (id) => {
+      const transport = networkManager.transport;
+      if (!transport) {
+        console.warn("[useNetworkState] despawn called before transport is ready.");
+        return;
+      }
+      if (!transport.isHost) {
+        console.warn("[useNetworkState] despawn is host-only.");
+        return;
+      }
+      if (!entitiesRef.current.has(id)) {
+        console.warn(
+          `[useNetworkState] entity "${id}" does not exist. Ignoring despawn.`
+        );
+        return;
+      }
+      applyDespawn(id);
+      channelRef.current?.send({ action: "despawn", id });
+    },
+    [networkManager, applyDespawn]
+  );
+  const requestSpawn = (0, import_react10.useCallback)(
+    (id, config) => {
+      const transport = networkManager.transport;
+      if (!transport) {
+        console.warn(
+          "[useNetworkState] requestSpawn called before transport is ready."
+        );
+        return;
+      }
+      if (transport.isHost) {
+        if (entitiesRef.current.has(id)) {
+          console.warn(
+            `[useNetworkState] entity "${id}" already exists. Ignoring requestSpawn.`
+          );
+          return;
+        }
+        const newState = {
+          id,
+          x: 0,
+          y: 0,
+          a: 0,
+          vx: 0,
+          vy: 0,
+          va: 0,
+          ...config
+        };
+        newState.id = id;
+        applySpawn(id, newState);
+        channelRef.current?.send({ action: "spawn", id, state: newState });
+        return;
+      }
+      channelRef.current?.send(
+        { action: "request-spawn", id, state: config },
+        transport.hostId
+      );
+    },
+    [networkManager, applySpawn]
+  );
+  const getState = (0, import_react10.useCallback)(
+    (id) => {
+      return entitiesRef.current.get(id);
+    },
+    []
+  );
+  const setState = (0, import_react10.useCallback)(
+    (id, partialState) => {
+      const transport = networkManager.transport;
+      if (!transport) {
+        console.warn("[useNetworkState] setState called before transport is ready.");
+        return;
+      }
+      if (!transport.isHost) {
+        console.warn("[useNetworkState] setState is host-only.");
+        return;
+      }
+      const existing = entitiesRef.current.get(id);
+      if (!existing) {
+        console.warn(
+          `[useNetworkState] entity "${id}" does not exist. Cannot setState.`
+        );
+        return;
+      }
+      const updated = {
+        ...existing,
+        ...partialState,
+        id
+        // id is immutable
+      };
+      replaceEntities((prev) => {
+        const next = new Map(prev);
+        next.set(id, updated);
+        return next;
+      });
+      channelRef.current?.send({ action: "spawn", id, state: updated });
+    },
+    [networkManager, replaceEntities]
+  );
+  return {
+    spawn,
+    despawn,
+    requestSpawn,
+    getState,
+    setState,
+    entities
+  };
+}
+
+// src/core/DebugOverlay.ts
+var QUALITY_COLORS = {
+  good: "#00ff00",
+  degraded: "#ffff00",
+  poor: "#ff4444"
+};
+var DebugOverlay = class {
+  constructor(options) {
+    this.visible = true;
+    this.lastHTML = "";
+    const opts = options ?? {};
+    this.keyboardToggle = opts.keyboardToggle ?? "F3";
+    this.el = document.createElement("div");
+    const pos = opts.position ?? "top-right";
+    const posStyles = this.positionStyles(pos);
+    Object.assign(this.el.style, {
+      position: "fixed",
+      ...posStyles,
+      background: "rgba(0,0,0,0.75)",
+      color: "#00ff00",
+      fontFamily: "'Courier New', monospace",
+      fontSize: "11px",
+      padding: "8px",
+      borderRadius: "4px",
+      zIndex: "99999",
+      pointerEvents: "none",
+      whiteSpace: "pre",
+      lineHeight: "1.4",
+      minWidth: "200px",
+      boxSizing: "border-box"
+    });
+    document.body.appendChild(this.el);
+    this.handleKey = (e) => {
+      if (e.key === this.keyboardToggle) {
+        e.preventDefault();
+        this.toggle();
+      }
+    };
+    window.addEventListener("keydown", this.handleKey);
+  }
+  /* ---- public API ---- */
+  update(stats) {
+    if (!this.visible) return;
+    const latencyDisplay = this.formatLatency(stats.latencyMs);
+    const qualityColor = QUALITY_COLORS[stats.networkQuality] ?? "#00ff00";
+    const bwIn = (stats.bandwidthIn / 1024).toFixed(1);
+    const bwOut = (stats.bandwidthOut / 1024).toFixed(1);
+    const loss = (stats.packetLossRate * 100).toFixed(1);
+    const html = `<b style="color:#00ccff">== NET DEBUG ==</b>
+tick       ${stats.tick}
+srv tick   ${stats.serverTick}
+drift      ${stats.drift}
+latency    ${latencyDisplay} ms
+loss       ${loss}%
+bw in      ${bwIn} KB/s
+bw out     ${bwOut} KB/s
+quality    <span style="color:${qualityColor}">${stats.networkQuality}</span>
+peers      ${stats.peerCount}
+host       ${stats.isHost ? "YES" : "NO"}
+sync       ${stats.syncMode}`;
+    if (html !== this.lastHTML) {
+      this.el.innerHTML = html;
+      this.lastHTML = html;
+    }
+  }
+  show() {
+    this.visible = true;
+    this.el.style.display = "block";
+  }
+  hide() {
+    this.visible = false;
+    this.el.style.display = "none";
+  }
+  toggle() {
+    if (this.visible) {
+      this.hide();
+    } else {
+      this.show();
+    }
+  }
+  destroy() {
+    window.removeEventListener("keydown", this.handleKey);
+    this.el.remove();
+  }
+  /* ---- helpers ---- */
+  positionStyles(pos) {
+    switch (pos) {
+      case "top-left":
+        return { top: "8px", left: "8px" };
+      case "top-right":
+        return { top: "8px", right: "8px" };
+      case "bottom-left":
+        return { bottom: "8px", left: "8px" };
+      case "bottom-right":
+        return { bottom: "8px", right: "8px" };
+    }
+  }
+  formatLatency(latency) {
+    if (typeof latency === "number") {
+      return latency.toFixed(1);
+    }
+    if (latency.size === 0) return "\u2014";
+    let sum = 0;
+    latency.forEach((v) => sum += v);
+    return (sum / latency.size).toFixed(1);
+  }
+};
+
+// src/core/InterestManager.ts
+var InterestManager = class {
+  constructor(options) {
+    this._cellSize = options?.cellSize ?? 50;
+    this._defaultRadius = options?.defaultRadius ?? 200;
+    this._alwaysRelevant = new Set(options?.alwaysRelevant ?? []);
+    this._cells = /* @__PURE__ */ new Map();
+    this._entityPositions = /* @__PURE__ */ new Map();
+  }
+  // ── Public API ──
+  /**
+   * Rebuild the spatial hash from the authoritative entity map.
+   * Called once per host tick before any relevance queries.
+   */
+  updateEntities(entities) {
+    this._cells.clear();
+    this._entityPositions.clear();
+    for (const [id, entity] of entities) {
+      const z = "z" in entity ? entity.z : 0;
+      const pos = { x: entity.x, y: entity.y, z };
+      this._entityPositions.set(id, pos);
+      const key = this._cellKey(pos.x, pos.y, pos.z);
+      let bucket = this._cells.get(key);
+      if (!bucket) {
+        bucket = /* @__PURE__ */ new Set();
+        this._cells.set(key, bucket);
+      }
+      bucket.add(id);
+    }
+  }
+  /**
+   * Return the set of entity ids relevant to a single client.
+   *
+   * Relevance is the *union* of:
+   *  1. Entities whose cell overlaps the client's bounding sphere
+   *  2. Entities in the `alwaysRelevant` set
+   *  3. Entities owned by this client
+   */
+  getRelevantEntities(clientPosition, clientId, owners, overrideRadius) {
+    const radius = overrideRadius ?? this._defaultRadius;
+    const cx = clientPosition.x;
+    const cy = clientPosition.y;
+    const cz = clientPosition.z ?? 0;
+    const result = /* @__PURE__ */ new Set();
+    const minCellX = Math.floor((cx - radius) / this._cellSize);
+    const maxCellX = Math.floor((cx + radius) / this._cellSize);
+    const minCellY = Math.floor((cy - radius) / this._cellSize);
+    const maxCellY = Math.floor((cy + radius) / this._cellSize);
+    const minCellZ = Math.floor((cz - radius) / this._cellSize);
+    const maxCellZ = Math.floor((cz + radius) / this._cellSize);
+    for (let ix = minCellX; ix <= maxCellX; ix++) {
+      for (let iy = minCellY; iy <= maxCellY; iy++) {
+        for (let iz = minCellZ; iz <= maxCellZ; iz++) {
+          const key = `${ix},${iy},${iz}`;
+          const bucket = this._cells.get(key);
+          if (bucket) {
+            for (const entityId of bucket) {
+              result.add(entityId);
+            }
+          }
+        }
+      }
+    }
+    for (const id of this._alwaysRelevant) {
+      if (this._entityPositions.has(id)) {
+        result.add(id);
+      }
+    }
+    for (const [entityId, ownerId] of owners) {
+      if (ownerId === clientId && this._entityPositions.has(entityId)) {
+        result.add(entityId);
+      }
+    }
+    return result;
+  }
+  /**
+   * Build a filter callback compatible with
+   * `HostAuthority.setInterestFilter`.
+   *
+   * The returned function closes over a single relevance pass for every
+   * known client so that per-entity filtering during broadcast is a cheap
+   * `Set.has` lookup.
+   *
+   * @param clientPositions  peerId -> position of that client's camera/player
+   * @param owners           entityId -> ownerPeerId
+   */
+  createFilter(clientPositions, owners) {
+    const relevanceSets = /* @__PURE__ */ new Map();
+    for (const [peerId, pos] of clientPositions) {
+      relevanceSets.set(
+        peerId,
+        this.getRelevantEntities(pos, peerId, owners)
+      );
+    }
+    return (entityId, peerId) => {
+      const set = relevanceSets.get(peerId);
+      if (!set) return true;
+      return set.has(entityId);
+    };
+  }
+  /** Remove all data from the grid. */
+  clear() {
+    this._cells.clear();
+    this._entityPositions.clear();
+  }
+  // ── Private helpers ──
+  _cellKey(x, y, z) {
+    const cx = Math.floor(x / this._cellSize);
+    const cy = Math.floor(y / this._cellSize);
+    const cz = Math.floor(z / this._cellSize);
+    return `${cx},${cy},${cz}`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DebugOverlay,
+  FirebaseStrategy,
+  InterestManager,
+  MqttStrategy,
+  MultiplayerBridge,
+  MultiplayerProvider,
+  NetworkSimulator,
+  useHost,
+  useLobby,
+  useMultiplayer,
+  useNetworkEvents,
+  useNetworkState,
+  usePlayers,
+  useRoom
+});
+//# sourceMappingURL=index.js.map