@carverjs/multiplayer 0.0.1

package/dist/transport.js

@@ -0,0 +1,1274 @@
+"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/index.ts
+var transport_exports = {};
+__export(transport_exports, {
+  FirebaseStrategy: () => FirebaseStrategy,
+  MqttStrategy: () => MqttStrategy,
+  PeerConnection: () => PeerConnection,
+  WebRTCTransport: () => WebRTCTransport,
+  buildICEConfig: () => buildICEConfig,
+  generatePeerId: () => generatePeerId
+});
+module.exports = __toCommonJS(transport_exports);
+
+// 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/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,
+  PeerConnection,
+  WebRTCTransport,
+  buildICEConfig,
+  generatePeerId
+});
+//# sourceMappingURL=transport.js.map