@carverjs/multiplayer 0.0.1

package/dist/strategy.js

@@ -0,0 +1,619 @@
+"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/transport/strategy/index.ts
+var strategy_exports = {};
+__export(strategy_exports, {
+  FirebaseStrategy: () => FirebaseStrategy,
+  MqttStrategy: () => MqttStrategy,
+  generatePeerId: () => generatePeerId
+});
+module.exports = __toCommonJS(strategy_exports);
+
+// 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FirebaseStrategy,
+  MqttStrategy,
+  generatePeerId
+});
+//# sourceMappingURL=strategy.js.map