@defcomm/meetingsdk 0.1.0 → 0.1.2

package/dist/index.js

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ActiveSpeakerDetector: () => ActiveSpeakerDetector,
   MeetingProvider: () => MeetingProvider,
   MeetingState: () => MeetingState,
   SFUClient: () => SFUClient,
@@ -41,9 +42,7 @@ var import_react2 = require("react");
 
 // src/config/ws.ts
 var SDK_CONFIG = {
-  // SFU API endpoint for token generation
   apiBase: "https://sfu-server.duckdns.org/api",
-  // SFU WebSocket endpoint for signaling
   wsBase: "wss://sfu-server.duckdns.org/ws",
   // Public STUN/TURN servers (fallback)
   iceServers: [
@@ -52,10 +51,170 @@ var SDK_CONFIG = {
   ],
   // Connection and reconnection settings
   connectionTimeout: 1e4,
-  maxReconnectAttempts: 5,
-  // Legacy WebSocket URL (if using the old mesh architecture)
-  wsUrl: "wss://sfu-server.duckdns.org/ws"
-  // kept for backward compatibility
+  maxReconnectAttempts: 5
+};
+
+// src/core/ActiveSpeakerDetector.ts
+var ActiveSpeakerDetector = class {
+  constructor(options = {}) {
+    this.audioContext = null;
+    this.speakers = /* @__PURE__ */ new Map();
+    this.timer = null;
+    this.lastEmitted = "";
+    this.intervalMs = options.intervalMs ?? 100;
+    this.threshold = options.threshold ?? 0.025;
+    this.releaseThreshold = options.releaseThreshold ?? 0.015;
+    this.releaseMs = options.releaseMs ?? 600;
+    this.onActiveSpeakersChanged = options.onActiveSpeakersChanged ?? (() => {
+    });
+  }
+  ensureAudioContext() {
+    if (!this.audioContext) {
+      const AudioContextClass = window.AudioContext || window.webkitAudioContext;
+      if (!AudioContextClass) {
+        throw new Error("Web Audio API is not supported by this browser");
+      }
+      this.audioContext = new AudioContextClass();
+    }
+    return this.audioContext;
+  }
+  async resume() {
+    if (!this.audioContext) return;
+    if (this.audioContext.state === "suspended") {
+      try {
+        await this.audioContext.resume();
+      } catch {
+      }
+    }
+  }
+  addTrack(participantId, track) {
+    if (!participantId) return;
+    if (track.kind !== "audio") return;
+    this.removeParticipant(participantId);
+    const context = this.ensureAudioContext();
+    const stream = new MediaStream([track]);
+    const source = context.createMediaStreamSource(stream);
+    const analyser = context.createAnalyser();
+    analyser.fftSize = 512;
+    analyser.smoothingTimeConstant = 0.65;
+    analyser.minDecibels = -90;
+    analyser.maxDecibels = -10;
+    source.connect(analyser);
+    const data = new Float32Array(analyser.fftSize);
+    const state = {
+      participantId,
+      track,
+      stream,
+      source,
+      analyser,
+      data,
+      active: false,
+      lastActiveAt: 0
+    };
+    this.speakers.set(participantId, state);
+    track.addEventListener(
+      "ended",
+      () => {
+        this.removeParticipant(participantId);
+      },
+      { once: true }
+    );
+    this.start();
+    void this.resume();
+  }
+  removeParticipant(participantId) {
+    const state = this.speakers.get(participantId);
+    if (!state) return;
+    state.active = false;
+    try {
+      state.source.disconnect();
+    } catch {
+    }
+    state.stream.getTracks().forEach((track) => {
+      if (track !== state.track) {
+        track.stop();
+      }
+    });
+    this.speakers.delete(participantId);
+    this.emitIfChanged();
+  }
+  removeTrack(track) {
+    for (const [participantId, state] of this.speakers) {
+      if (state.track === track) {
+        this.removeParticipant(participantId);
+      }
+    }
+  }
+  clear() {
+    for (const participantId of this.speakers.keys()) {
+      this.removeParticipant(participantId);
+    }
+    this.speakers.clear();
+    this.stop();
+    this.emitIfChanged(true);
+  }
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => this.sample(), this.intervalMs);
+  }
+  stop() {
+    if (!this.timer) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+  sample() {
+    const now = performance.now();
+    for (const state of this.speakers.values()) {
+      if (state.track.readyState !== "live" || state.track.muted || !state.track.enabled) {
+        if (state.active) {
+          state.active = false;
+        }
+        continue;
+      }
+      state.analyser.getFloatTimeDomainData(state.data);
+      let sumSquares = 0;
+      for (let i = 0; i < state.data.length; i++) {
+        const sample = state.data[i];
+        sumSquares += sample * sample;
+      }
+      const rms = Math.sqrt(sumSquares / state.data.length);
+      if (!state.active) {
+        if (rms >= this.threshold) {
+          state.active = true;
+          state.lastActiveAt = now;
+        }
+      } else {
+        if (rms >= this.releaseThreshold) {
+          state.lastActiveAt = now;
+        } else if (now - state.lastActiveAt >= this.releaseMs) {
+          state.active = false;
+        }
+      }
+    }
+    this.emitIfChanged();
+  }
+  getActiveSpeakerIds() {
+    return Array.from(this.speakers.values()).filter((speaker) => speaker.active).map((speaker) => speaker.participantId);
+  }
+  emitIfChanged(force = false) {
+    const ids = this.getActiveSpeakerIds().sort();
+    const key = ids.join("|");
+    if (!force && key === this.lastEmitted) {
+      return;
+    }
+    this.lastEmitted = key;
+    this.onActiveSpeakersChanged(ids);
+  }
+  async destroy() {
+    this.clear();
+    if (this.audioContext) {
+      try {
+        await this.audioContext.close();
+      } catch {
+      }
+      this.audioContext = null;
+    }
+  }
 };
 
 // src/core/MeetingState.ts
@@ -66,6 +225,7 @@ var MeetingState = class {
     this.localStream = null;
     this.chatMessages = /* @__PURE__ */ new Map();
     this.presenterId = null;
+    this.activeSpeakerIds = /* @__PURE__ */ new Set();
     this.listeners = /* @__PURE__ */ new Map();
   }
   // ---- reactive system ----
@@ -87,6 +247,14 @@ var MeetingState = class {
     this.notify("presenter");
     this.notify("participants");
   }
+  setActiveSpeakers(ids) {
+    const next = new Set(ids);
+    if (next.size === this.activeSpeakerIds.size && [...next].every((id) => this.activeSpeakerIds.has(id))) {
+      return;
+    }
+    this.activeSpeakerIds = next;
+    this.notify("activeSpeakers");
+  }
   // ---- participants ----
   addParticipant(p) {
     if (this.participants.has(p.id)) return false;
@@ -200,9 +368,11 @@ var MeetingState = class {
     this.participants.clear();
     this.chatMessages.clear();
     this.presenterId = null;
+    this.activeSpeakerIds = /* @__PURE__ */ new Set();
     this.notify("participants");
     this.notify("chat");
     this.notify("presenter");
+    this.notify("activeSpeakers");
   }
 };
 
@@ -1330,7 +1500,7 @@ var SFUClient = class {
 
 // src/core/VideoCore.ts
 var VideoSDKCore = class {
-  constructor(events = {}, apiBase = SDK_CONFIG.apiBase || "https://api.example.com/api", wsBase = SDK_CONFIG.wsBase || "wss://api.example.com/ws") {
+  constructor(events = {}, apiBase = SDK_CONFIG.apiBase, wsBase = SDK_CONFIG.wsBase) {
     this.events = events;
     this.apiBase = apiBase;
     this.wsBase = wsBase;
@@ -1346,8 +1516,16 @@ var VideoSDKCore = class {
     this.intentionalDisconnect = false;
     this.remoteStreams = /* @__PURE__ */ new Map();
     this.remoteScreenStreams = /* @__PURE__ */ new Map();
+    this.joinPromise = null;
+    this.disconnectPromise = null;
     this.state = new MeetingState();
     this.events = events;
+    this.activeSpeakerDetector = new ActiveSpeakerDetector({
+      onActiveSpeakersChanged: (participantIds) => {
+        this.state.setActiveSpeakers(participantIds);
+        this.events.onActiveSpeakersChanged?.(participantIds);
+      }
+    });
     let storedId = null;
     try {
       storedId = typeof localStorage !== "undefined" ? localStorage.getItem("defcomm:participant_id") : null;
@@ -1373,7 +1551,7 @@ var VideoSDKCore = class {
     this.events.onError?.(err);
     console.error("[MeetingSDK Error]", err);
   }
-  // ============ LOCAL MEDIA ============
+  // LOCAL MEDIA
   async initLocal(video, name) {
     this.participantName = name;
     try {
@@ -1388,6 +1566,10 @@ var VideoSDKCore = class {
           autoGainControl: true
         }
       });
+      const localAudioTrack = this.localStream.getAudioTracks()[0];
+      if (localAudioTrack) {
+        this.activeSpeakerDetector.addTrack(this.myId, localAudioTrack);
+      }
       const hasVideo = this.localStream.getVideoTracks().some((t) => t.readyState === "live");
       const hasAudio = this.localStream.getAudioTracks().some((t) => t.readyState === "live");
       if (!hasVideo || !hasAudio) {
@@ -1418,7 +1600,7 @@ var VideoSDKCore = class {
     });
     this.state.localStream = this.localStream;
   }
-  // ============ CONNECTION / SIGNALLING ============
+  // ROOM MANAGEMENT
   async createRoom(input) {
     const client = this.sfuClient ?? new SFUClient({
       apiBase: this.apiBase,
@@ -1443,11 +1625,43 @@ var VideoSDKCore = class {
     });
     return client.deleteRoom(roomCode);
   }
+  // JOIN
   async joinMeeting(config) {
-    const { roomId, name, audioMuted = false, videoMuted = false } = config;
+    const {
+      roomId,
+      name,
+      audioMuted = false,
+      videoMuted = false,
+      userId
+    } = config;
     if (!roomId || !name) {
       throw new Error("roomId and name are required to join meeting");
     }
+    if (userId) {
+      this.myId = userId;
+    }
+    if (this.sfuClient && this.room.id === roomId && this.sfuClient.getConnectionState() === "connected") {
+      console.info("[SDK] Already connected; duplicate join ignored", {
+        roomId,
+        userId: this.myId
+      });
+      return;
+    }
+    if (this.joinPromise) {
+      console.info(
+        "[SDK] Join already in progress; waiting for existing join",
+        {
+          roomId,
+          userId: this.myId
+        }
+      );
+      return this.joinPromise;
+    }
+    if (this.sfuClient && this.room.id && this.room.id !== roomId) {
+      throw new Error(
+        `Already connected to room ${this.room.id}. Leave the current meeting before joining another room.`
+      );
+    }
     this.intentionalDisconnect = false;
     this.participantName = name;
     this.room.id = roomId;
@@ -1457,6 +1671,10 @@ var VideoSDKCore = class {
         video: true,
         audio: true
       });
+      const localAudioTrack = this.localStream.getAudioTracks()[0];
+      if (localAudioTrack) {
+        this.activeSpeakerDetector.addTrack(this.myId, localAudioTrack);
+      }
     }
     this.localStream.getAudioTracks().forEach((track) => {
       track.enabled = !audioMuted;
@@ -1465,24 +1683,45 @@ var VideoSDKCore = class {
       track.enabled = !videoMuted;
     });
     this.updateLocalMedia(audioMuted, videoMuted);
-    return this.connect(roomId, name);
+    const promise = this.connect(roomId, name);
+    this.joinPromise = promise;
+    try {
+      await promise;
+    } finally {
+      if (this.joinPromise === promise) {
+        this.joinPromise = null;
+      }
+    }
   }
+  // SFU CONNECTION
   async connect(roomId, name) {
     if (this.sfuClient) {
-      await this.sfuClient.leave();
-      this.sfuClient = null;
+      const state = this.sfuClient.getConnectionState();
+      if (this.room.id === roomId && (state === "connecting" || state === "connected" || state === "reconnecting")) {
+        console.info(
+          "[SDK] Existing SFU connection is active; connect ignored",
+          {
+            roomId,
+            state
+          }
+        );
+        return;
+      }
+      throw new Error(
+        `SFU client already exists in state "${state}". Disconnect explicitly before creating another connection.`
+      );
     }
     const client = new SFUClient({
       apiBase: this.apiBase,
       wsBase: this.wsBase,
       userId: this.myId,
       autoSubscribe: true,
-      onStateChange: (state) => this.handleSFUState(state),
+      // CONNECTION STATE
+      onStateChange: (state) => {
+        this.handleSFUState(state);
+      },
       onConnected: (payload, resumed) => {
-        console.log(
-          `[SFU] ${resumed ? "Resumed" : "Joined"} room`,
-          payload
-        );
+        console.log(`[SFU] ${resumed ? "Resumed" : "Joined"} room`, payload);
         this.state.updateLocalParticipant({
           id: this.myId,
           name: this.participantName
@@ -1494,6 +1733,7 @@ var VideoSDKCore = class {
       onReconnecting: (attempt) => {
         console.warn(`[SFU] Reconnecting, attempt ${attempt}`);
       },
+      // ADMISSION CONTROL
       onJoinPending: (info) => {
         console.log("[SFU] Join request pending", info);
         this.events.onEntryRequested?.({
@@ -1506,7 +1746,10 @@ var VideoSDKCore = class {
         console.log("[SFU] Join approved", requestId);
         this.events.onJoinApproved?.(requestId);
         this.events.onEntryResponded?.(
-          { participantId: this.myId, decision: "approved" },
+          {
+            participantId: this.myId,
+            decision: "approved"
+          },
           "approved"
         );
       },
@@ -1514,13 +1757,19 @@ var VideoSDKCore = class {
         console.warn("[SFU] Join rejected", requestId, reason);
         this.events.onJoinRejected?.(requestId);
         this.events.onEntryResponded?.(
-          { participantId: this.myId, decision: "rejected" },
+          {
+            participantId: this.myId,
+            decision: "rejected"
+          },
           "rejected"
         );
         this.emitError(
           "JOIN_REJECTED",
           reason || "Your request to join was rejected",
-          { requestId, reason },
+          {
+            requestId,
+            reason
+          },
           false
         );
       },
@@ -1528,16 +1777,21 @@ var VideoSDKCore = class {
         const requestId = request?.request_id || request?.requestId;
         const userId = request?.user_id || request?.userId;
         const nameValue = request?.user_metadata?.name || request?.display_name || request?.name || "Participant";
-        if (!requestId || !userId) return;
+        if (!requestId || !userId) {
+          return;
+        }
         this.events.onEntryRequested?.({
           requestId,
           userId,
           name: nameValue
         });
       },
+      // PARTICIPANTS
       onParticipantJoined: (participant) => {
         const pid = participant.participant_id;
-        if (!pid || pid === this.myId) return;
+        if (!pid || pid === this.myId) {
+          return;
+        }
         const pname = participant.user_metadata?.name || participant.display_name || "Participant";
         this.state.addParticipant({
           id: pid,
@@ -1556,9 +1810,13 @@ var VideoSDKCore = class {
         });
       },
       onParticipantPresence: (participantId, presence) => {
-        if (participantId === this.myId) return;
+        if (participantId === this.myId) {
+          return;
+        }
         const current = this.state.getParticipant(participantId);
-        if (!current) return;
+        if (!current) {
+          return;
+        }
         const connectionState = presence === "reconnecting" ? "reconnecting" : presence === "connected" || presence === "online" ? "connected" : presence === "disconnected" ? "disconnected" : current.connectionState;
         this.state.updateParticipantMedia(participantId, {
           stream: current.media?.stream ?? null
@@ -1574,19 +1832,24 @@ var VideoSDKCore = class {
       },
       onParticipantLeft: (participant) => {
         const pid = typeof participant === "string" ? participant : participant.participant_id;
-        if (!pid) return;
+        if (!pid) {
+          return;
+        }
         console.log("[SFU] Participant permanently left", pid);
         this.cleanupRemoteParticipant(pid);
         this.state.removeParticipant(pid);
         this.events.onUserLeft?.(pid);
       },
+      // TRACKS
       onTrackPublished: (track) => {
         console.log("[SFU] Track published", track);
       },
       onTrackUnpublished: (track) => {
         console.log("[SFU] Track unpublished", track);
         const pid = track.participant_id;
-        if (!pid) return;
+        if (!pid) {
+          return;
+        }
         const current = this.state.getParticipant(pid);
         if (track.source === "screen") {
           const screen = this.remoteScreenStreams.get(pid);
@@ -1600,7 +1863,9 @@ var VideoSDKCore = class {
           this.events.onScreenShareStopped?.(pid);
           return;
         }
-        if (!current) return;
+        if (!current) {
+          return;
+        }
         this.state.updateParticipantMedia(pid, {
           stream: current.media?.stream ?? null,
           micEnabled: track.kind === "audio" ? false : current.media?.micEnabled ?? true,
@@ -1609,9 +1874,13 @@ var VideoSDKCore = class {
       },
       onTrackStateChanged: (track) => {
         const pid = track.participant_id;
-        if (!pid || pid === this.myId) return;
+        if (!pid || pid === this.myId) {
+          return;
+        }
         const current = this.state.getParticipant(pid);
-        if (!current) return;
+        if (!current) {
+          return;
+        }
         if (track.source === "audio") {
           this.state.updateParticipantMedia(pid, {
             stream: current.media?.stream ?? null,
@@ -1627,17 +1896,22 @@ var VideoSDKCore = class {
         }
         this.events.onTrackStateChanged?.(track);
       },
+      // RECORDING
       onRecordingStarted: (recording) => {
         this.events.onRecordingStarted?.(recording);
       },
       onRecordingStopped: (recording) => {
         this.events.onRecordingStopped?.(recording);
       },
+      // REMOTE MEDIA
       onRemoteTrack: (track, stream, metadata) => {
         this.handleRemoteTrack(track, stream, metadata);
       },
+      // SCREEN SHARE
       onScreenShareStarted: (participantId, track) => {
-        if (participantId === this.myId) return;
+        if (participantId === this.myId) {
+          return;
+        }
         console.log("[SFU] Screen share started", participantId, track);
         const current = this.state.getParticipant(participantId);
         if (current) {
@@ -1648,7 +1922,9 @@ var VideoSDKCore = class {
         }
       },
       onScreenShareStopped: (participantId) => {
-        if (participantId === this.myId) return;
+        if (participantId === this.myId) {
+          return;
+        }
         const screen = this.remoteScreenStreams.get(participantId);
         screen?.getTracks().forEach((track) => track.stop());
         this.remoteScreenStreams.delete(participantId);
@@ -1659,18 +1935,25 @@ var VideoSDKCore = class {
         });
         this.events.onScreenShareStopped?.(participantId);
       },
+      // ERROR
       onError: (error) => {
         console.error("[SFU] Error:", error);
-        this.emitError("SFU_ERROR", error?.message || String(error), error, true);
+        this.emitError(
+          "SFU_ERROR",
+          error?.message || String(error),
+          error,
+          true
+        );
       }
     });
     this.sfuClient = client;
     client.setLocalStream(this.localStream);
-    return client.getToken(roomId, {
+    await client.getToken(roomId, {
       displayName: name,
       userId: this.myId
     });
   }
+  // SFU STATE
   handleSFUState(state) {
     this.events.onConnectionStateChanged?.(state);
     if (state === "reconnecting") {
@@ -1689,9 +1972,12 @@ var VideoSDKCore = class {
       );
     }
   }
+  // REMOTE TRACKS
   handleRemoteTrack(track, stream, metadata) {
     const participantId = metadata?.participant_id;
-    if (!participantId || participantId === this.myId) return;
+    if (!participantId || participantId === this.myId) {
+      return;
+    }
     const source = metadata.source;
     if (source === "screen") {
       let screenStream = this.remoteScreenStreams.get(participantId);
@@ -1736,39 +2022,47 @@ var VideoSDKCore = class {
       cameraTrack: track.kind === "video" ? track : current?.media?.cameraTrack,
       audioTrack: track.kind === "audio" ? track : current?.media?.audioTrack
     });
+    if (track.kind === "audio") {
+      this.activeSpeakerDetector.addTrack(participantId, track);
+    }
     this.events.onTrack?.(remoteStream, participantId);
     track.onended = () => {
       if (track.kind === "video") {
-        const participant2 = this.state.getParticipant(participantId);
         this.state.updateParticipantMedia(participantId, {
           camEnabled: false,
           stream: remoteStream
         });
         return;
       }
-      const participant = this.state.getParticipant(participantId);
       this.state.updateParticipantMedia(participantId, {
         micEnabled: false,
         stream: remoteStream
       });
     };
   }
+  // MEETING
   getMeeting() {
     return this.room;
   }
-  // ============ ADMISSION CONTROL ============
+  // ADMISSION CONTROL
   async approveJoinRequest(requestId) {
-    if (!this.sfuClient) throw new Error("SFU client is not connected");
+    if (!this.sfuClient) {
+      throw new Error("SFU client is not connected");
+    }
     return this.sfuClient.approveJoinRequest(requestId);
   }
   async rejectJoinRequest(requestId, reason) {
-    if (!this.sfuClient) throw new Error("SFU client is not connected");
+    if (!this.sfuClient) {
+      throw new Error("SFU client is not connected");
+    }
     return this.sfuClient.rejectJoinRequest(requestId, reason);
   }
-  // ============ MEDIA CONTROL ============
+  // MEDIA CONTROL
   toggleMic() {
     const mediaState = this.state.localParticipant?.media;
-    if (!mediaState || !this.localStream) return;
+    if (!mediaState || !this.localStream) {
+      return;
+    }
     const nextEnabled = !mediaState.micEnabled;
     this.localStream.getAudioTracks().forEach((track) => {
       track.enabled = nextEnabled;
@@ -1776,14 +2070,18 @@ var VideoSDKCore = class {
     this.state.updateLocalParticipant({
       id: this.myId,
       name: this.participantName,
-      media: { micEnabled: nextEnabled }
+      media: {
+        micEnabled: nextEnabled
+      }
     });
     this.sfuClient?.muteAudio(!nextEnabled);
     this.events.onMicToggled?.(this.myId, nextEnabled);
   }
   toggleCam() {
     const mediaState = this.state.localParticipant?.media;
-    if (!mediaState || !this.localStream) return;
+    if (!mediaState || !this.localStream) {
+      return;
+    }
     const nextEnabled = !mediaState.camEnabled;
     this.localStream.getVideoTracks().forEach((track) => {
       track.enabled = nextEnabled;
@@ -1791,12 +2089,14 @@ var VideoSDKCore = class {
     this.state.updateLocalParticipant({
       id: this.myId,
       name: this.participantName,
-      media: { camEnabled: nextEnabled }
+      media: {
+        camEnabled: nextEnabled
+      }
     });
     this.sfuClient?.muteVideo(!nextEnabled);
     this.events.onCamToggled?.(this.myId, nextEnabled);
   }
-  // ============ SCREEN SHARING ============
+  // SCREEN SHARING
   async startScreenShare() {
     try {
       if (!navigator.mediaDevices?.getDisplayMedia) {
@@ -1828,7 +2128,9 @@ var VideoSDKCore = class {
     }
   }
   stopScreenShare() {
-    if (!this.screenStream) return;
+    if (!this.screenStream) {
+      return;
+    }
     void this.sfuClient?.stopScreenShare();
     this.screenStream.getTracks().forEach((track) => track.stop());
     this.screenStream = null;
@@ -1841,7 +2143,7 @@ var VideoSDKCore = class {
       }
     });
   }
-  // ============ RECORDING ============
+  // RECORDING
   async startRecording() {
     if (!this.sfuClient) {
       throw new Error("SFU client is not connected");
@@ -1860,7 +2162,7 @@ var VideoSDKCore = class {
     }
     return this.sfuClient.getRecordingStatus();
   }
-  // ============ CHAT ============
+  // CHAT
   sendChatMessage(payload) {
     if (!this.sfuClient) {
       console.warn("SFU Client not connected");
@@ -1879,8 +2181,9 @@ var VideoSDKCore = class {
     this.state.addChatMessage(msg);
     this.events.onChatMessage?.(msg);
   }
-  // ============ CLEANUP ============
+  // CLEANUP
   cleanupRemoteParticipant(participantId) {
+    this.activeSpeakerDetector.removeParticipant(participantId);
     const stream = this.remoteStreams.get(participantId);
     stream?.getTracks().forEach((track) => track.stop());
     this.remoteStreams.delete(participantId);
@@ -1888,16 +2191,34 @@ var VideoSDKCore = class {
     screen?.getTracks().forEach((track) => track.stop());
     this.remoteScreenStreams.delete(participantId);
   }
+  // DISCONNECT
   async disconnect() {
+    if (this.disconnectPromise) {
+      return this.disconnectPromise;
+    }
+    this.disconnectPromise = this.performDisconnect();
+    try {
+      await this.disconnectPromise;
+    } finally {
+      this.disconnectPromise = null;
+    }
+  }
+  async performDisconnect() {
     this.intentionalDisconnect = true;
-    await this.sfuClient?.leave();
+    this.joinPromise = null;
+    const client = this.sfuClient;
     this.sfuClient = null;
+    if (client) {
+      await client.leave();
+    }
     if (this.localStream) {
       this.localStream.getTracks().forEach((track) => track.stop());
       this.localStream = null;
     }
-    this.screenStream?.getTracks().forEach((track) => track.stop());
-    this.screenStream = null;
+    if (this.screenStream) {
+      this.screenStream.getTracks().forEach((track) => track.stop());
+      this.screenStream = null;
+    }
     this.isScreenSharing = false;
     for (const stream of this.remoteStreams.values()) {
       stream.getTracks().forEach((track) => track.stop());
@@ -1946,6 +2267,9 @@ var MeetingProvider = ({
   const trackStateListeners = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
   const recordingStartedListeners = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
   const recordingStoppedListeners = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const activeSpeakerListeners = (0, import_react2.useRef)(
+    /* @__PURE__ */ new Set()
+  );
   if (!sdkRef.current) {
     sdkRef.current = new VideoSDKCore({
       onError: (err) => errorListeners.current.forEach((fn) => fn(err)),
@@ -1958,6 +2282,11 @@ var MeetingProvider = ({
     });
   }
   const sdk = sdkRef.current;
+  const activeSpeakerIds = useMeetingStore(
+    sdk.state,
+    "activeSpeakers",
+    (s) => Array.from(s.activeSpeakerIds)
+  );
   const presenterId = useMeetingStore(
     sdk.state,
     "presenter",
@@ -2006,6 +2335,7 @@ var MeetingProvider = ({
       participants,
       messages,
       presenterId,
+      activeSpeakerIds,
       usePubSub: (topic) => {
         if (topic !== "SECURE_CHAT") {
           throw new Error(`Unsupported PubSub argument: "${topic}"`);
@@ -2055,6 +2385,12 @@ var MeetingProvider = ({
       onRecordingStopped: (cb) => {
         recordingStoppedListeners.current.add(cb);
         return () => recordingStoppedListeners.current.delete(cb);
+      },
+      onActiveSpeakersChanged: (cb) => {
+        activeSpeakerListeners.current.add(cb);
+        return () => {
+          activeSpeakerListeners.current.delete(cb);
+        };
       }
     };
   }, [config, sdk, localParticipant, participants, messages, presenterId]);
@@ -2118,6 +2454,10 @@ var useMeeting = (handlers) => {
     if (!handlers?.onError) return;
     return ctx.onError(handlers.onError);
   }, [handlers?.onError]);
+  (0, import_react4.useEffect)(() => {
+    if (!handlers?.onActiveSpeakersChanged) return;
+    return ctx.onActiveSpeakersChanged(handlers.onActiveSpeakersChanged);
+  }, [handlers?.onActiveSpeakersChanged]);
   (0, import_react4.useEffect)(() => {
     if (!handlers?.onEntryRequested) return;
     return ctx.onEntryRequested(handlers.onEntryRequested);
@@ -2275,6 +2615,7 @@ function useMeetingPreview(roomId, userId) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ActiveSpeakerDetector,
   MeetingProvider,
   MeetingState,
   SFUClient,