@afosecure/meshsdk 0.1.1 → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,1404 @@
+// src/react/useLocalParticipant.tsx
+import { useCallback, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+
+// src/react/MeetingProvider.tsx
+import { createContext, useContext, useMemo, useRef } from "react";
+
+// src/config/ws.ts
+var SDK_CONFIG = {
+  wsUrl: "wss://https://rust-video-server-sfyf.onrender.com/ws",
+  baseUrl: "https://https://rust-video-server-sfyf.onrender.com"
+};
+
+// src/core/MeetingState.ts
+var MeetingState = class {
+  constructor() {
+    this.participants = /* @__PURE__ */ new Map();
+    this.localParticipant = null;
+    this.localStream = null;
+    this.chatMessages = /* @__PURE__ */ new Map();
+    this.presenterId = null;
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  // ---- reactive system ----
+  subscribe(scope, fn) {
+    if (!this.listeners.has(scope)) {
+      this.listeners.set(scope, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(scope).add(fn);
+    return () => {
+      this.listeners.get(scope)?.delete(fn);
+    };
+  }
+  notify(scope) {
+    this.listeners.get(scope)?.forEach((fn) => fn());
+  }
+  setPresenterId(id) {
+    if (this.presenterId === id) return;
+    this.presenterId = id;
+    this.notify("presenter");
+    this.notify("participants");
+  }
+  // ---- participants ----
+  addParticipant(p) {
+    if (this.participants.has(p.id)) return false;
+    const next = new Map(this.participants);
+    next.set(p.id, p);
+    this.participants = next;
+    this.notify("participants");
+    return true;
+  }
+  removeParticipant(id) {
+    const next = new Map(this.participants);
+    next.delete(id);
+    this.participants = next;
+    this.notify("participants");
+  }
+  updateParticipantMedia(id, patch) {
+    const p = this.participants.get(id);
+    if (!p) return;
+    const updated = {
+      ...p,
+      media: {
+        stream: null,
+        screenStream: void 0,
+        cameraTrack: void 0,
+        screenTrack: void 0,
+        audioTrack: void 0,
+        micEnabled: true,
+        camEnabled: true,
+        isScreenSharing: false,
+        ...p.media,
+        ...patch
+      }
+    };
+    const next = new Map(this.participants);
+    next.set(id, updated);
+    this.participants = next;
+    this.notify(`participant:${id}`);
+    this.notify("participants");
+  }
+  updateLocalParticipant(patch) {
+    const prev = this.localParticipant;
+    if (!prev) {
+      this.localParticipant = {
+        id: patch.id ?? "",
+        name: patch.name ?? "",
+        media: {
+          stream: patch.media?.stream ?? null,
+          // ◄ FIX: Capture the stream from the patch here
+          screenStream: patch.media?.screenStream,
+          cameraTrack: patch.media?.cameraTrack,
+          screenTrack: patch.media?.screenTrack,
+          audioTrack: patch.media?.audioTrack,
+          micEnabled: patch.media?.micEnabled ?? true,
+          camEnabled: patch.media?.camEnabled ?? true,
+          isScreenSharing: patch.media?.isScreenSharing ?? false
+        }
+      };
+      this.notify("localParticipant");
+      return;
+    }
+    const prevMedia = prev.media ?? {
+      stream: null,
+      screenStream: void 0,
+      cameraTrack: void 0,
+      screenTrack: void 0,
+      audioTrack: void 0,
+      micEnabled: true,
+      camEnabled: true,
+      isScreenSharing: false
+    };
+    const nextMedia = {
+      stream: patch.media?.stream ?? prevMedia.stream,
+      screenStream: patch.media?.screenStream ?? prevMedia.screenStream,
+      cameraTrack: patch.media?.cameraTrack ?? prevMedia.cameraTrack,
+      screenTrack: patch.media?.screenTrack ?? prevMedia.screenTrack,
+      audioTrack: patch.media?.audioTrack ?? prevMedia.audioTrack,
+      micEnabled: patch.media?.micEnabled ?? prevMedia.micEnabled,
+      camEnabled: patch.media?.camEnabled ?? prevMedia.camEnabled,
+      isScreenSharing: patch.media?.isScreenSharing ?? prevMedia.isScreenSharing
+    };
+    this.localParticipant = {
+      ...prev,
+      id: patch.id ?? prev.id,
+      name: patch.name ?? prev.name,
+      media: nextMedia
+    };
+    this.notify("localParticipant");
+  }
+  // ---- chat ----
+  addChatMessage(msg) {
+    this.chatMessages.set(msg.id, msg);
+    this.notify("chat");
+  }
+  getChatMessages() {
+    return Array.from(this.chatMessages.values()).sort(
+      (a, b) => a.timestamp - b.timestamp
+    );
+  }
+  clearChat() {
+    this.chatMessages.clear();
+    this.notify("chat");
+  }
+  // ---- helpers ----
+  getParticipants() {
+    return Array.from(this.participants.values());
+  }
+  getParticipant(id) {
+    return this.participants.get(id) ?? null;
+  }
+  resetRemoteState() {
+    this.participants.clear();
+    this.chatMessages.clear();
+    this.presenterId = null;
+    this.notify("participants");
+    this.notify("chat");
+    this.notify("presenter");
+  }
+};
+
+// src/core/VideoCore.ts
+var VideoSDKCore = class {
+  constructor(events = {}, url = SDK_CONFIG.wsUrl) {
+    this.events = events;
+    this.url = url;
+    this.ws = null;
+    this.peers = {};
+    this.initiators = /* @__PURE__ */ new Set();
+    this.lastPong = Date.now();
+    this.iceServers = [];
+    this.intentionalDisconnect = false;
+    this.room = {
+      id: null,
+      name: null
+    };
+    this.localStream = null;
+    this.screenStream = null;
+    this.isScreenSharing = false;
+    this.screenSenders = {};
+    this.pingInterval = null;
+    this.pendingIceCandidates = {};
+    this.pendingOffers = {};
+    this.reconnectAttempts = 0;
+    this.participantName = "";
+    // Track if we're in the waiting room (pending approval)
+    this.isWaitingForApproval = false;
+    this.pendingRequestId = null;
+    this.iceTransportPolicy = "all";
+    this.state = new MeetingState();
+    this.events = events;
+    this.url = url;
+    this.myId = localStorage.getItem("vsdk_id") || crypto.randomUUID();
+    localStorage.setItem("vsdk_id", this.myId);
+  }
+  emitError(code, message, raw, recoverable = true) {
+    const err = {
+      code,
+      message,
+      raw,
+      roomId: this.room.id,
+      userId: this.myId,
+      recoverable
+    };
+    this.events.onError?.(err);
+    this.joinRejecter?.(err);
+    this.joinRejecter = void 0;
+    console.error("[MeetingSDK Error]", err);
+  }
+  // ---------------- STREAM ----------------
+  async initLocal(video, name) {
+    this.participantName = name;
+    try {
+      this.localStream = await navigator.mediaDevices.getUserMedia({
+        video: {
+          width: { ideal: 1280 },
+          height: { ideal: 720 }
+        },
+        audio: {
+          echoCancellation: true,
+          noiseSuppression: true,
+          autoGainControl: true
+        }
+      });
+      const hasVideo = this.localStream.getVideoTracks().some((t) => t.readyState === "live");
+      const hasAudio = this.localStream.getAudioTracks().some((t) => t.readyState === "live");
+      if (!hasVideo || !hasAudio) {
+        throw new Error(`Missing tracks: video=${hasVideo}, audio=${hasAudio}`);
+      }
+      video.srcObject = this.localStream;
+      this.state.updateLocalParticipant({
+        id: this.myId,
+        name: this.participantName,
+        media: {
+          stream: this.localStream,
+          micEnabled: true,
+          camEnabled: true,
+          isScreenSharing: false
+        }
+      });
+      this.state.localStream = this.localStream;
+    } catch (err) {
+      this.emitError("GET_USER_MEDIA_FAILED", err?.message, err, false);
+      throw err;
+    }
+  }
+  // ---------------- CONNECT ----------------
+  async connect(roomId, name) {
+    this.room.id = roomId;
+    this.reset();
+    return new Promise((resolve, reject) => {
+      this.joinResolver = resolve;
+      this.joinRejecter = reject;
+      this.ws = new WebSocket(this.url);
+      this.ws.onopen = () => {
+        console.log("WebSocket connected, sending JOIN...");
+        this.send({
+          type: "JOIN",
+          room_id: roomId,
+          user_id: this.myId,
+          sender_name: name,
+          camera_stream_id: this.localStream?.id.replace(/[{}]/g, ""),
+          audio_muted: this.state.localParticipant?.media?.micEnabled,
+          video_muted: this.state.localParticipant?.media?.camEnabled
+        });
+      };
+      this.ws.onerror = (err) => {
+        this.emitError("WS_ERROR", "WebSocket encountered an error", err, true);
+      };
+      this.ws.onclose = (e) => {
+        this.joinRejecter?.({
+          code: "WS_CLOSED",
+          message: "Connection closed before join completed",
+          raw: e
+        });
+        this.joinRejecter = void 0;
+        if (this.intentionalDisconnect) {
+          return;
+        }
+        if (e.code === 1e3 || e.code === 1001) {
+          return;
+        }
+        if (this.isWaitingForApproval) {
+          return;
+        }
+        this.scheduleReconnect();
+      };
+      this.ws.onmessage = async (e) => {
+        await this.handle(JSON.parse(e.data));
+      };
+    });
+  }
+  async joinMeeting(config) {
+    const { roomId, name, audioMuted = false, videoMuted = false } = config;
+    if (!roomId || !name) {
+      throw new Error("roomId and name are required to join meeting");
+    }
+    this.participantName = name;
+    if (!this.localStream) {
+      this.localStream = await navigator.mediaDevices.getUserMedia({
+        video: true,
+        audio: true
+      });
+    }
+    this.localStream.getAudioTracks().forEach((t) => {
+      t.enabled = !audioMuted;
+    });
+    this.localStream.getVideoTracks().forEach((t) => {
+      t.enabled = !videoMuted;
+    });
+    this.state.updateLocalParticipant({
+      id: this.myId,
+      name: this.participantName,
+      media: {
+        stream: this.localStream,
+        micEnabled: !audioMuted,
+        camEnabled: !videoMuted,
+        isScreenSharing: false
+      }
+    });
+    this.state.localStream = this.localStream;
+    await this.connect(roomId, name);
+  }
+  getMeeting() {
+    return this.room;
+  }
+  toggleMic() {
+    const mediaState = this.state.localParticipant?.media;
+    if (!mediaState) return;
+    const nextEnabled = !mediaState.micEnabled;
+    this.localStream?.getAudioTracks().forEach((t) => t.enabled = nextEnabled);
+    this.state.updateLocalParticipant({
+      id: this.myId,
+      name: this.participantName,
+      media: {
+        ...mediaState,
+        micEnabled: nextEnabled
+      }
+    });
+    this.send({
+      type: "MEDIA_STATE",
+      kind: "audio",
+      enabled: nextEnabled
+    });
+  }
+  toggleCam() {
+    const mediaState = this.state.localParticipant?.media;
+    if (!mediaState) return;
+    const nextEnabled = !mediaState.camEnabled;
+    this.localStream?.getVideoTracks().forEach((t) => t.enabled = nextEnabled);
+    this.state.updateLocalParticipant({
+      id: this.myId,
+      name: this.participantName,
+      media: {
+        ...mediaState,
+        camEnabled: nextEnabled
+      }
+    });
+    this.send({
+      type: "MEDIA_STATE",
+      kind: "video",
+      enabled: nextEnabled
+    });
+  }
+  scheduleReconnect() {
+    if (!this.room.id) return;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts), 3e4);
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = window.setTimeout(async () => {
+      try {
+        await this.connect(this.room.id, this.participantName);
+        this.reconnectAttempts = 0;
+      } catch {
+        this.reconnectAttempts++;
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.pingInterval = setInterval(() => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+      this.send({
+        type: "PING",
+        client_ts: Date.now()
+      });
+    }, 2e4);
+  }
+  stopHeartbeat() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  // ---------------- RESET ----------------
+  reset() {
+    Object.values(this.peers).forEach((pc) => pc.close());
+    this.peers = {};
+    this.initiators.clear();
+    this.pendingIceCandidates = {};
+    this.state.resetRemoteState();
+  }
+  async handleJoinApproved(msg) {
+    console.log("JOIN_APPROVED received, sending new JOIN...");
+    this.events.onEntryResponded?.({
+      participantId: msg.user_id,
+      decision: "approved"
+    });
+    this.isWaitingForApproval = false;
+    this.pendingRequestId = null;
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.send({
+        type: "JOIN",
+        room_id: this.room.id,
+        user_id: this.myId,
+        sender_name: this.participantName
+      });
+      console.log("Sent new JOIN after approval");
+    }
+  }
+  async handle(msg) {
+    var _a, _b, _c, _d;
+    if (msg.sender === this.myId) return;
+    switch (msg.type) {
+      case "PONG":
+        this.lastPong = Date.now();
+        break;
+      case "OFFER":
+        console.log("[Offer] Received from", msg.sender, {
+          sdp: msg.payload.substring(0, 200)
+        });
+        await this.handleOffer(msg.payload, msg.sender);
+        break;
+      case "ANSWER": {
+        const pc = this.peers[msg.sender];
+        console.log("[Answer] Received from", msg.sender, {
+          signalingState: pc?.signalingState,
+          iceConnectionState: pc?.iceConnectionState,
+          connectionState: pc?.connectionState
+        });
+        if (!pc) return;
+        if (pc.signalingState !== "have-local-offer") {
+          console.warn(
+            `[Signaling] Unexpected ANSWER in state "${pc.signalingState}", ignoring`
+          );
+          return;
+        }
+        try {
+          await pc.setRemoteDescription({
+            type: "answer",
+            sdp: msg.payload
+          });
+          await this.flushIce(msg.sender, pc);
+        } catch (err) {
+          console.error("[Signaling] Failed to apply answer:", err);
+          this.emitError(
+            "ANSWER_FAILED",
+            `Failed to apply answer from ${msg.sender}`,
+            err,
+            true
+          );
+        }
+        break;
+      }
+      case "ICE": {
+        const candidate = JSON.parse(msg.payload);
+        let pc = this.peers[msg.sender];
+        if (!pc) {
+          (_a = this.pendingIceCandidates)[_b = msg.sender] ?? (_a[_b] = []);
+          this.pendingIceCandidates[msg.sender].push(candidate);
+          break;
+        }
+        if (!pc.remoteDescription) {
+          (_c = this.pendingIceCandidates)[_d = msg.sender] ?? (_c[_d] = []);
+          this.pendingIceCandidates[msg.sender].push(candidate);
+          break;
+        }
+        try {
+          await pc.addIceCandidate(candidate);
+        } catch (err) {
+          console.warn("ICE error:", err);
+        }
+        break;
+      }
+      case "EXISTING_USERS":
+        if (msg.presenterId) {
+          this.state.setPresenterId(msg.presenterId);
+          this.events.onScreenShareStarted?.(msg.presenterId, null);
+          this.state.setPresenterId(msg.presenterId);
+        }
+        for (const p of msg.participants || []) {
+          if (!p?.id || p.id === this.myId) continue;
+          const structuredParticipant = {
+            id: p.id,
+            name: p.name,
+            isHost: p.isHost,
+            isPresenter: p.isPresenter,
+            media: {
+              stream: null,
+              screenStream: void 0,
+              cameraTrack: void 0,
+              screenTrack: void 0,
+              audioTrack: void 0,
+              micEnabled: p.micEnabled ?? true,
+              camEnabled: p.camEnabled ?? true,
+              isScreenSharing: p.isScreenSharing ?? false,
+              remoteScreenStreamId: p.remoteScreenStreamId || void 0,
+              cameraStreamId: p.cameraId || void 0
+            }
+          };
+          this.state.addParticipant(structuredParticipant);
+          this.events.onUserJoined?.(structuredParticipant);
+          if (p.isScreenSharing && p.remoteScreenStreamId) {
+            this.state.setPresenterId(p.id);
+            this.state.updateParticipantMedia(p.id, {
+              isScreenSharing: true,
+              remoteScreenStreamId: p.remoteScreenStreamId,
+              cameraStreamId: p.cameraId || null
+            });
+          }
+          if (this.shouldInitiate(p.id)) {
+            await this.createOffer(p.id);
+          }
+        }
+        break;
+      case "JOINED": {
+        if (msg.iceServers) {
+          this.iceServers = msg.iceServers;
+        }
+        this.room.name = msg.room_name;
+        this.isWaitingForApproval = false;
+        this.pendingRequestId = null;
+        this.intentionalDisconnect = false;
+        this.reconnectAttempts = 0;
+        if (Object.keys(this.pendingOffers).length > 0) {
+          console.log(
+            "Processing",
+            Object.keys(this.pendingOffers).length,
+            "pending offers"
+          );
+          for (const [peerId2, sdp] of Object.entries(this.pendingOffers)) {
+            await this.handleOffer(sdp, peerId2);
+          }
+          this.pendingOffers = {};
+        }
+        const media = this.state.localParticipant?.media;
+        if (media) {
+          this.send({
+            type: "MEDIA_STATE",
+            kind: "audio",
+            enabled: !!media.micEnabled
+          });
+          this.send({
+            type: "MEDIA_STATE",
+            kind: "video",
+            enabled: !!media.camEnabled
+          });
+        }
+        this.startHeartbeat();
+        this.joinResolver?.();
+        this.joinResolver = void 0;
+        this.joinRejecter = void 0;
+        break;
+      }
+      case "USER_JOINED": {
+        const p = msg.participant;
+        if (!p?.id || p.id === this.myId) return;
+        this.state.addParticipant(p);
+        this.events.onUserJoined?.(p);
+        if (this.shouldInitiate(p.id)) {
+          await this.createOffer(p.id);
+        }
+        break;
+      }
+      case "JOIN_PENDING": {
+        const req = msg.request;
+        this.isWaitingForApproval = true;
+        this.pendingRequestId = req.request_id;
+        this.events.onEntryRequested?.({
+          requestId: req.request_id,
+          userId: req.user_id,
+          name: req.name
+        });
+        break;
+      }
+      case "JOIN_REQUEST": {
+        const req = msg.request;
+        this.events.onEntryRequested?.({
+          requestId: req.id,
+          userId: req.user_id,
+          name: req.name
+        });
+        break;
+      }
+      case "JOIN_APPROVED": {
+        await this.handleJoinApproved(msg);
+        break;
+      }
+      case "JOIN_REJECTED": {
+        const decision = "rejected";
+        this.isWaitingForApproval = false;
+        this.pendingRequestId = null;
+        this.events.onEntryResponded?.({
+          participantId: msg.user_id,
+          decision
+        });
+        break;
+      }
+      case "USER_LEFT":
+        const peerId = msg.participant.id;
+        this.closePeer(peerId);
+        this.state.removeParticipant(peerId);
+        this.events.onUserLeft?.(peerId);
+        break;
+      case "MEDIA_STATE_CHANGE": {
+        const peerId2 = msg.peerId;
+        const { kind, enabled } = msg;
+        if (kind === "audio") {
+          this.state.updateParticipantMedia(peerId2, { micEnabled: enabled });
+          this.events.onMicToggled?.(peerId2, enabled);
+        } else if (kind === "video") {
+          this.state.updateParticipantMedia(peerId2, { camEnabled: enabled });
+          this.events.onCamToggled?.(peerId2, enabled);
+        }
+        break;
+      }
+      case "CHAT_MESSAGE": {
+        const newMsg = msg.data;
+        if (newMsg.sender_id === this.myId) break;
+        this.state.addChatMessage({
+          id: newMsg.id,
+          text: newMsg.message,
+          sender_id: newMsg.sender_id,
+          sender_name: newMsg.sender_name,
+          timestamp: new Date(newMsg.timestamp).getTime(),
+          target: newMsg.target
+        });
+        this.events.onChatMessage?.(msg);
+        break;
+      }
+      case "SCREEN_SHARE_START": {
+        const peerId2 = msg.peerId;
+        this.state.updateParticipantMedia(peerId2, {
+          isScreenSharing: true,
+          remoteScreenStreamId: msg.stream_id,
+          cameraStreamId: msg?.camera_stream_id
+        });
+        if (!this.state.presenterId) {
+          this.state.setPresenterId(peerId2);
+        }
+        const screenStream = this.state.getParticipant(peerId2)?.media?.screenStream;
+        this.events.onScreenShareStarted?.(peerId2, screenStream || null);
+        break;
+      }
+      case "SCREEN_SHARE_STOP": {
+        const peerId2 = msg.peerId;
+        this.state.updateParticipantMedia(peerId2, { isScreenSharing: false });
+        if (this.state.presenterId === peerId2) {
+          this.state.setPresenterId(null);
+        }
+        this.events.onScreenShareStopped?.(peerId2);
+        break;
+      }
+      case "ERROR": {
+        const fatal = msg?.fatal === true;
+        this.emitError(
+          "WS_ERROR",
+          msg?.message || "Unknown error",
+          msg,
+          !fatal
+        );
+        if (fatal) {
+          this.disconnect();
+        }
+        return;
+      }
+    }
+  }
+  // ---------------- PEER ----------------
+  createPeer(id) {
+    if (!this.localStream) throw new Error("No local stream");
+    if (!this.iceServers || this.iceServers.length === 0) {
+      throw new Error(
+        "ICE Servers not configured. Backend must provide iceServers on JOIN."
+      );
+    }
+    const pc = new RTCPeerConnection({
+      iceServers: this.iceServers,
+      iceTransportPolicy: this.iceTransportPolicy
+    });
+    pc.ontrack = (event) => {
+      const incomingStream = event.streams?.[0] || new MediaStream([event.track]);
+      const streamId = incomingStream?.id?.replace(/[{}]/g, "");
+      const participant = this.state.getParticipant(id);
+      const isCameraStream = streamId && participant?.media?.cameraStreamId && streamId === participant?.media?.cameraStreamId;
+      const isScreenStream = streamId && participant?.media?.remoteScreenStreamId && streamId === participant?.media?.remoteScreenStreamId;
+      if (event.track.muted) {
+        event.track.onunmute = () => {
+          console.log(`${event.track.kind} track unmuted for ${id}`);
+        };
+      }
+      if (isScreenStream) {
+        const videoTrack = event.track.kind === "video" ? event.track : incomingStream.getVideoTracks()[0] || participant?.media?.screenTrack;
+        this.state.updateParticipantMedia(id, {
+          screenStream: incomingStream,
+          screenTrack: videoTrack,
+          remoteScreenStreamId: incomingStream.id,
+          isScreenSharing: true
+        });
+        if (!this.state.presenterId) {
+          this.state.setPresenterId(id);
+        }
+        this.events.onScreenShareStarted?.(id, incomingStream);
+        console.log(`Screen share stream detected for ${id}`);
+      } else if (isCameraStream) {
+        this.state.updateParticipantMedia(id, {
+          stream: incomingStream,
+          cameraTrack: incomingStream.getVideoTracks()[0],
+          audioTrack: incomingStream.getAudioTracks()[0]
+        });
+        this.events.onTrack?.(incomingStream, id);
+      } else {
+        this.state.updateParticipantMedia(id, {
+          stream: incomingStream,
+          cameraTrack: incomingStream.getVideoTracks()[0],
+          audioTrack: incomingStream.getAudioTracks()[0]
+        });
+        this.events.onTrack?.(incomingStream, id);
+      }
+    };
+    pc.onicecandidate = (e) => {
+      if (!e.candidate) return;
+      console.log("LOCAL ICE:", e.candidate.candidate);
+      this.send({
+        type: "ICE",
+        payload: JSON.stringify(e.candidate),
+        sender: this.myId,
+        target: id
+      });
+    };
+    pc.oniceconnectionstatechange = async () => {
+      console.log("================================");
+      console.log(`Peer: ${id}`);
+      console.log(`ICE: ${pc.iceConnectionState}`);
+      console.log(`Connection: ${pc.connectionState}`);
+      console.log(`Signaling: ${pc.signalingState}`);
+      if (pc.iceConnectionState === "disconnected") {
+        const stats = await pc.getStats();
+        stats.forEach((report) => {
+          if (report.type === "transport") {
+            console.log(JSON.stringify(report, null, 2));
+          }
+        });
+      }
+    };
+    pc.onconnectionstatechange = () => {
+      if (pc.connectionState === "failed") {
+        try {
+          pc.restartIce();
+        } catch {
+        }
+      }
+    };
+    this.localStream.getTracks().forEach((track) => {
+      pc.addTrack(track, this.localStream);
+    });
+    if (this.isScreenSharing && this.screenStream) {
+      this.screenSenders[id] = [];
+      this.screenStream.getTracks().forEach((track) => {
+        const sender = pc.addTrack(track, this.screenStream);
+        this.screenSenders[id].push(sender);
+      });
+    }
+    return pc;
+  }
+  // ---------------- OFFER ----------------
+  async createOffer(id, isRenegotiation = false) {
+    if (!isRenegotiation && !this.shouldInitiate(id)) {
+      console.debug(
+        `[Offer] ${id} should initiate (${id} > ${this.myId}), skipping`
+      );
+      return;
+    }
+    if (!isRenegotiation && this.initiators.has(id)) {
+      console.debug(
+        `[Offer] Already initiating with ${id}, skipping duplicate`
+      );
+      return;
+    }
+    if (!isRenegotiation) {
+      this.initiators.add(id);
+    }
+    if (!this.peers[id]) {
+      this.peers[id] = this.createPeer(id);
+    }
+    const pc = this.peers[id];
+    try {
+      const offer = await pc.createOffer();
+      await pc.setLocalDescription(offer);
+      this.send({
+        type: "OFFER",
+        payload: offer.sdp,
+        sender: this.myId,
+        target: id
+      });
+      console.debug(`[Offer] Sent to ${id}`);
+    } catch (err) {
+      console.error(`[Offer] Failed for ${id}:`, err);
+    }
+  }
+  shouldInitiate(peerId) {
+    return this.myId < peerId;
+  }
+  // ---------------- ANSWER ----------------
+  async handleOffer(sdp, id) {
+    if (!this.iceServers || this.iceServers.length === 0) {
+      console.warn("[Offer] Waiting for iceServers, queuing offer from", id);
+      this.pendingOffers[id] = sdp;
+      return;
+    }
+    if (!this.peers[id]) {
+      this.peers[id] = this.createPeer(id);
+    }
+    const pc = this.peers[id];
+    try {
+      if (pc.signalingState === "have-local-offer") {
+        if (this.shouldInitiate(id)) {
+          console.warn(
+            `[Glare] Both sent OFFERs, we win (${this.myId} < ${id}), keeping our OFFER`
+          );
+          return;
+        } else {
+          console.warn(
+            `[Glare] Both sent OFFERs, they win (${id} < ${this.myId}), rolling back`
+          );
+          pc.close();
+          delete this.peers[id];
+          this.initiators.delete(id);
+          this.peers[id] = this.createPeer(id);
+        }
+      }
+      if (this.peers[id].signalingState !== "stable" && this.peers[id].signalingState !== "have-local-offer") {
+        console.warn(
+          `[Signaling] Cannot accept OFFER in state "${this.peers[id].signalingState}"`
+        );
+        return;
+      }
+      await this.peers[id].setRemoteDescription({
+        type: "offer",
+        sdp
+      });
+      const pending = this.pendingIceCandidates[id] || [];
+      for (const candidate of pending) {
+        try {
+          await this.peers[id].addIceCandidate(candidate);
+        } catch (err) {
+          console.warn("[ICE] Failed to add candidate:", err);
+        }
+      }
+      delete this.pendingIceCandidates[id];
+      const answer = await this.peers[id].createAnswer();
+      await this.peers[id].setLocalDescription(answer);
+      await this.flushIce(id, this.peers[id]);
+      this.send({
+        type: "ANSWER",
+        payload: answer.sdp,
+        sender: this.myId,
+        target: id
+      });
+      console.debug(`[Answer] Sent to ${id}`);
+    } catch (err) {
+      console.error(`[Signaling] Failed to handle OFFER from ${id}:`, err);
+      this.emitError(
+        "OFFER_HANDLING_FAILED",
+        `Failed to handle offer from ${id}`,
+        err,
+        true
+      );
+    }
+  }
+  // ---------------- CLEANUP ----------------
+  closePeer(id) {
+    const pc = this.peers[id];
+    if (!pc) return;
+    pc.ontrack = null;
+    pc.onicecandidate = null;
+    pc.onconnectionstatechange = null;
+    pc.close();
+    delete this.peers[id];
+    this.initiators.delete(id);
+    this.state.removeParticipant(id);
+  }
+  async startScreenShare() {
+    try {
+      if (this.state.presenterId && this.state.presenterId !== this.myId) {
+        throw new Error("Another user is already sharing their screen.");
+      }
+      if (!navigator.mediaDevices?.getDisplayMedia) {
+        throw new Error("Screen sharing not supported on this device");
+      }
+      this.screenStream = await navigator.mediaDevices.getDisplayMedia({
+        video: true
+        // audio: true,
+      });
+      this.isScreenSharing = true;
+      this.state.updateLocalParticipant({
+        media: {
+          isScreenSharing: true,
+          screenStream: this.screenStream,
+          screenTrack: this.screenStream.getVideoTracks()[0]
+        }
+      });
+      this.state.setPresenterId(this.myId);
+      this.screenStream.getVideoTracks()[0].onended = () => {
+        this.stopScreenShare();
+      };
+      Object.entries(this.peers).forEach(([peerId, pc]) => {
+        this.screenSenders[peerId] = [];
+        this.screenStream.getTracks().forEach((track) => {
+          const sender = pc.addTrack(track, this.screenStream);
+          this.screenSenders[peerId].push(sender);
+        });
+        this.createOffer(peerId, true);
+      });
+      this.send({
+        type: "SCREEN_SHARE_START",
+        sender: this.myId,
+        room_id: this.room.id,
+        camera_id: this.localStream?.id.replace(/[{}]/g, ""),
+        stream_id: this.screenStream.id.replace(/[{}]/g, "")
+      });
+      return this.screenStream;
+    } catch (err) {
+      this.emitError(
+        "SCREEN_SHARE_FAILED",
+        err?.message || "Failed to start screen sharing",
+        err,
+        true
+      );
+      this.isScreenSharing = false;
+      this.screenStream = null;
+      throw err;
+    }
+  }
+  stopScreenShare() {
+    if (!this.screenStream) return;
+    this.screenStream.getTracks().forEach((t) => t.stop());
+    Object.entries(this.peers).forEach(([peerId, pc]) => {
+      const senders = this.screenSenders[peerId] || [];
+      senders.forEach((sender) => {
+        try {
+          pc.removeTrack(sender);
+        } catch (err) {
+          console.warn(err);
+        }
+      });
+      delete this.screenSenders[peerId];
+      this.createOffer(peerId, true);
+    });
+    this.screenStream = null;
+    this.isScreenSharing = false;
+    this.state.updateLocalParticipant({
+      media: {
+        isScreenSharing: false,
+        screenStream: null,
+        screenTrack: void 0
+      }
+    });
+    if (this.state.presenterId === this.myId) {
+      this.state.setPresenterId(null);
+    }
+    this.send({
+      type: "SCREEN_SHARE_STOP",
+      sender: this.myId,
+      room_id: this.room.id
+    });
+  }
+  sendChatMessage(payload) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      console.warn("WS not connected");
+      return;
+    }
+    if (!this.room.id) {
+      console.warn("No roomId set");
+      return;
+    }
+    const isPrivate = !!payload?.target;
+    const senderName = this.state.localParticipant?.name || "Anonymous";
+    const msg = {
+      id: crypto.randomUUID(),
+      sender_id: this.myId,
+      sender_name: senderName,
+      text: payload.message.trim(),
+      timestamp: Date.now(),
+      reply_to: payload.reply_to ?? null,
+      target: payload.target ?? null
+    };
+    this.state.addChatMessage(msg);
+    this.send({
+      type: "CHAT_MESSAGE",
+      message: payload.message.trim(),
+      user_id: this.myId,
+      sender_name: senderName,
+      room_id: this.room.id,
+      target: isPrivate ? payload.target ?? null : null,
+      reply_to: payload.reply_to ?? null,
+      client_ts: Date.now()
+    });
+  }
+  disconnect() {
+    this.intentionalDisconnect = true;
+    this.stopScreenShare();
+    Object.values(this.peers).forEach((pc) => pc.close());
+    this.peers = {};
+    this.initiators.clear();
+    this.stopHeartbeat();
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.send({
+        type: "LEAVE",
+        room_id: this.room.id,
+        user_id: this.myId,
+        sender_name: this.state.localParticipant?.name
+      });
+      setTimeout(() => {
+        this.ws?.close(1e3, "Leaving meeting");
+        this.ws = null;
+      }, 50);
+    }
+    if (this.localStream) {
+      this.localStream.getTracks().forEach((track) => track.stop());
+      this.localStream = null;
+    }
+    this.room.id = null;
+    this.state.localParticipant = null;
+    this.state.notify("localParticipant");
+    this.state.participants.clear();
+    this.state.notify("participants");
+    this.events.onMeetingLeft?.();
+    this.state.clearChat();
+    this.state.setPresenterId(null);
+  }
+  async flushIce(id, pc) {
+    const pending = this.pendingIceCandidates[id];
+    if (!pending?.length) return;
+    for (const candidate of pending) {
+      try {
+        await pc.addIceCandidate(candidate);
+      } catch (e) {
+        console.warn("ICE flush error", e);
+      }
+    }
+    delete this.pendingIceCandidates[id];
+  }
+  send(msg) {
+    this.ws?.send(JSON.stringify(msg));
+  }
+  approveJoinRequest(requestId) {
+    this.send({
+      type: "JOIN_APPROVE",
+      request_id: requestId
+    });
+  }
+  rejectJoinRequest(requestId) {
+    this.send({
+      type: "JOIN_REJECT",
+      request_id: requestId
+    });
+  }
+};
+
+// src/react/useMeetingStore.ts
+import { useEffect, useState } from "react";
+function useMeetingStore(stateManager, scope, selector) {
+  const [state, setState] = useState(() => selector(stateManager));
+  useEffect(() => {
+    const unsubscribe = stateManager.subscribe(scope, () => {
+      setState(selector(stateManager));
+    });
+    return unsubscribe;
+  }, [stateManager, scope, selector]);
+  return state;
+}
+
+// src/react/MeetingProvider.tsx
+import { jsx } from "react/jsx-runtime";
+var MeetingContext = createContext(null);
+var MeetingProvider = ({
+  config,
+  children
+}) => {
+  const sdkRef = useRef(null);
+  const errorListeners = useRef(/* @__PURE__ */ new Set());
+  const entryRequestListeners = useRef(/* @__PURE__ */ new Set());
+  const entryResponseListeners = useRef(
+    /* @__PURE__ */ new Set()
+  );
+  const meetingLeftListeners = useRef(/* @__PURE__ */ new Set());
+  if (!sdkRef.current) {
+    sdkRef.current = new VideoSDKCore({
+      onError: (err) => errorListeners.current.forEach((fn) => fn(err)),
+      onEntryRequested: (req) => entryRequestListeners.current.forEach((fn) => fn(req)),
+      onEntryResponded: (p, d) => entryResponseListeners.current.forEach((fn) => fn(p, d)),
+      onMeetingLeft: () => meetingLeftListeners.current.forEach((fn) => fn())
+    });
+  }
+  const sdk = sdkRef.current;
+  const presenterId = useMeetingStore(
+    sdk.state,
+    "presenter",
+    (s) => s.presenterId
+  );
+  const participants = useMeetingStore(
+    sdk.state,
+    "participants",
+    (s) => s.participants
+  );
+  const localParticipant = useMeetingStore(
+    sdk.state,
+    "localParticipant",
+    (s) => s.localParticipant
+  );
+  const messages = useMeetingStore(
+    sdk.state,
+    "chat",
+    (s) => s.getChatMessages()
+  );
+  const value = useMemo(() => {
+    if (!sdkRef.current) {
+      sdkRef.current = new VideoSDKCore({
+        onError: (err) => {
+          errorListeners.current.forEach((fn) => fn(err));
+        }
+      });
+    }
+    return {
+      sdk,
+      join: (joinConfig) => sdk.joinMeeting({
+        ...config,
+        ...joinConfig
+      }),
+      leave: () => sdk.disconnect(),
+      toggleMic: sdk.toggleMic.bind(sdk),
+      toggleCam: sdk.toggleCam.bind(sdk),
+      startScreenShare: sdk.startScreenShare.bind(sdk),
+      stopScreenShare: sdk.stopScreenShare.bind(sdk),
+      sendMessage: sdk.sendChatMessage.bind(sdk),
+      room: sdk.getMeeting(),
+      localParticipant,
+      participants,
+      messages,
+      presenterId,
+      usePubSub: (topic) => {
+        if (topic !== "SECURE_CHAT") {
+          throw new Error(`Unsupported PubSub argument: "${topic}"`);
+        }
+        return {
+          messages: sdk.state.getChatMessages(),
+          publish: sdk.sendChatMessage.bind(sdk)
+        };
+      },
+      approveJoinRequest: sdk.approveJoinRequest.bind(sdk),
+      rejectJoinRequest: sdk.rejectJoinRequest.bind(sdk),
+      onError: (cb) => {
+        errorListeners.current.add(cb);
+        return () => {
+          errorListeners.current.delete(cb);
+        };
+      },
+      onEntryRequested: (cb) => {
+        entryRequestListeners.current.add(cb);
+        return () => {
+          entryRequestListeners.current.delete(cb);
+        };
+      },
+      onEntryResponded: (cb) => {
+        entryResponseListeners.current.add(cb);
+        return () => {
+          entryResponseListeners.current.delete(cb);
+        };
+      },
+      onMeetingLeft: (cb) => {
+        meetingLeftListeners.current.add(cb);
+        return () => {
+          meetingLeftListeners.current.delete(cb);
+        };
+      }
+    };
+  }, [config, sdk, localParticipant, participants, messages, presenterId]);
+  return /* @__PURE__ */ jsx(MeetingContext.Provider, { value, children });
+};
+var useMeetingContext = () => {
+  const ctx = useContext(MeetingContext);
+  if (!ctx)
+    throw new Error("useMeetingContext must be used inside <MeetingProvider>");
+  return ctx;
+};
+
+// src/react/useLocalParticipant.tsx
+var useLocalParticipant = () => {
+  const { sdk } = useMeetingContext();
+  const [localParticipant, setLocalParticipant] = useState2(
+    () => {
+      const current = sdk.state.localParticipant;
+      return current && current.id ? current : null;
+    }
+  );
+  useEffect2(() => {
+    const unsubscribe = sdk.state.subscribe("localParticipant", () => {
+      const current = sdk.state.localParticipant;
+      if (current && current.id) {
+        setLocalParticipant({ ...current });
+      } else {
+        setLocalParticipant(null);
+      }
+    });
+    return unsubscribe;
+  }, [sdk]);
+  const lastStreamRef = useRef2(null);
+  const videoRef = useCallback(
+    (video) => {
+      if (!video) return;
+      const stream = localParticipant?.media?.stream;
+      if (!stream) return;
+      if (lastStreamRef.current === stream) return;
+      lastStreamRef.current = stream;
+      video.srcObject = stream;
+      video.autoplay = true;
+      video.playsInline = true;
+      video.play().catch((err) => {
+        console.warn(`Autoplay failed for local view:`, err);
+      });
+    },
+    [localParticipant?.media?.stream]
+  );
+  return {
+    participant: localParticipant,
+    videoRef
+  };
+};
+
+// src/react/useMeeting.ts
+import { useEffect as useEffect3 } from "react";
+var useMeeting = (handlers) => {
+  const ctx = useMeetingContext();
+  useEffect3(() => {
+    if (!handlers?.onError) return;
+    return ctx.onError(handlers.onError);
+  }, [handlers?.onError]);
+  useEffect3(() => {
+    if (!handlers?.onEntryRequested) return;
+    return ctx.onEntryRequested(handlers.onEntryRequested);
+  }, [handlers?.onEntryRequested]);
+  useEffect3(() => {
+    if (!handlers?.onEntryResponded) return;
+    return ctx.onEntryResponded(handlers.onEntryResponded);
+  }, [handlers?.onEntryResponded]);
+  useEffect3(() => {
+    if (!handlers?.onMeetingLeft) return;
+    return ctx.onMeetingLeft(handlers.onMeetingLeft);
+  }, [handlers?.onMeetingLeft]);
+  const { sdk: _, ...publicApi } = ctx;
+  return publicApi;
+};
+
+// src/react/useParticipants.ts
+import { useEffect as useEffect4, useState as useState3 } from "react";
+var useParticipants = () => {
+  const { sdk } = useMeetingContext();
+  const [participants, setParticipants] = useState3(
+    () => sdk.state.getParticipants()
+  );
+  useEffect4(() => {
+    const update = () => {
+      setParticipants(sdk.state.getParticipants());
+    };
+    update();
+    const unsub = sdk.state.subscribe("participants", update);
+    return unsub;
+  }, [sdk]);
+  return participants;
+};
+
+// src/react/useRemoteMedia.ts
+import { useEffect as useEffect5, useRef as useRef3, useState as useState4 } from "react";
+var useRemoteMedia = (participantId) => {
+  const { sdk } = useMeetingContext();
+  const videoRef = useRef3(null);
+  const audioRef = useRef3(null);
+  const [participant, setParticipant] = useState4(
+    () => sdk.state.getParticipant(participantId) || null
+  );
+  useEffect5(() => {
+    const unsub = sdk.state.subscribe(`participant:${participantId}`, () => {
+      const p = sdk.state.getParticipant(participantId);
+      setParticipant(p ? { ...p } : null);
+    });
+    return unsub;
+  }, [participantId, sdk]);
+  useEffect5(() => {
+    const stream = participant?.media?.stream;
+    if (!stream) return;
+    if (videoRef.current) {
+      videoRef.current.srcObject = stream;
+      videoRef.current.muted = true;
+      videoRef.current.playsInline = true;
+      videoRef.current.play().catch(() => {
+      });
+    }
+    if (audioRef.current) {
+      audioRef.current.srcObject = stream;
+      audioRef.current.play().catch(() => {
+      });
+    }
+  }, [participant?.media?.stream]);
+  return {
+    videoRef,
+    audioRef,
+    isCamActive: !!participant?.media?.camEnabled,
+    isMicEnabled: !!participant?.media?.micEnabled
+  };
+};
+
+// src/react/useMeetingPreview.ts
+import { useEffect as useEffect6, useState as useState5 } from "react";
+function useMeetingPreview(roomId, userId) {
+  const [room, setRoom] = useState5(null);
+  const [error, setError] = useState5(null);
+  const [isConnected, setIsConnected] = useState5(false);
+  const [isLoading, setIsLoading] = useState5(true);
+  useEffect6(() => {
+    if (!roomId || !userId) {
+      setIsLoading(false);
+      return;
+    }
+    let ws = null;
+    const heartbeat = setInterval(() => {
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(
+          JSON.stringify({
+            type: "PING"
+          })
+        );
+      }
+    }, 2e4);
+    ws = new WebSocket(`${SDK_CONFIG.wsUrl}/watch/${roomId}?user_id=${userId}`);
+    ws.onopen = () => {
+      setIsConnected(true);
+      setError(null);
+      console.log("[Preview] watcher connected");
+    };
+    ws.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(event.data);
+        if (msg.type !== "ROOM_PRESENCE_UPDATE") {
+          return;
+        }
+        setRoom({
+          active: msg.active ?? false,
+          count: msg.count ?? 0,
+          canJoin: msg.canJoin ?? false,
+          approved: msg.approved ?? false,
+          isHost: msg.isHost ?? false,
+          hasMoreParticipants: msg.hasMoreParticipants ?? false,
+          participants: msg.participants ?? []
+        });
+        setIsLoading(false);
+      } catch (err) {
+        console.error("Invalid room presence payload", err);
+        setIsLoading(false);
+      }
+    };
+    ws.onerror = () => {
+      setError("Failed to connect to room monitor");
+      setIsLoading(false);
+    };
+    ws.onclose = () => {
+      setIsConnected(false);
+      console.log("[Preview] disconnected");
+    };
+    return () => {
+      clearInterval(heartbeat);
+      if (ws) {
+        ws.close(1e3, "Leaving preview");
+      }
+    };
+  }, [roomId, userId]);
+  return {
+    room,
+    isConnected,
+    isLoading,
+    error
+  };
+}
+export {
+  MeetingProvider,
+  MeetingState,
+  VideoSDKCore,
+  useLocalParticipant,
+  useMeeting,
+  useMeetingContext,
+  useMeetingPreview,
+  useParticipants,
+  useRemoteMedia
+};
+//# sourceMappingURL=index.mjs.map