@carverjs/multiplayer 0.0.1

package/dist/chunk-3KT73N2S.mjs

@@ -0,0 +1,655 @@
+// 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;
+  }
+};
+
+export {
+  buildICEConfig,
+  PeerConnection,
+  WebRTCTransport
+};
+//# sourceMappingURL=chunk-3KT73N2S.mjs.map