@defcomm/meetingsdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2289 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MeetingProvider: () => MeetingProvider,
+  MeetingState: () => MeetingState,
+  SFUClient: () => SFUClient,
+  VideoSDKCore: () => VideoSDKCore,
+  useLocalParticipant: () => useLocalParticipant,
+  useMeeting: () => useMeeting,
+  useMeetingContext: () => useMeetingContext,
+  useMeetingPreview: () => useMeetingPreview,
+  useParticipants: () => useParticipants,
+  useRemoteMedia: () => useRemoteMedia
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/react/useLocalParticipant.tsx
+var import_react3 = require("react");
+
+// src/react/MeetingProvider.tsx
+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: [
+    { urls: ["stun:stun.l.google.com:19302"] },
+    { urls: ["stun:stun1.l.google.com:19302"] }
+  ],
+  // 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
+};
+
+// 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/SFUClient.ts
+var SFUClient = class {
+  constructor(options = {}) {
+    this.ws = null;
+    this.publisher = null;
+    this.subscriber = null;
+    this.localStream = null;
+    this.screenStream = null;
+    this.videoSender = null;
+    this.audioSender = null;
+    this.screenSender = null;
+    this.iceServers = [];
+    this.requestId = 0;
+    this.publisherRevision = 0;
+    this.currentParticipantId = null;
+    this.token = null;
+    this.room = null;
+    this.resumeToken = null;
+    this.pendingJoinRequestId = null;
+    this.joinOptions = {};
+    this.state = "idle";
+    this.intentionalClose = false;
+    this.leaveAcknowledged = false;
+    this.joiningWithResume = false;
+    this.reconnectTimer = null;
+    this.reconnectAttempt = 0;
+    this.maxReconnectAttempts = 8;
+    this.reconnectBaseMs = 750;
+    this.joinWaiter = null;
+    this.pendingIce = {
+      publisher: [],
+      subscriber: []
+    };
+    this.subscriberNegotiating = false;
+    this.offerQueue = [];
+    this.subscriptionQueue = [];
+    this.subscriptionRunning = false;
+    this.subscriptionWaiters = [];
+    this.subscribedTracks = /* @__PURE__ */ new Set();
+    this.trackMetadata = /* @__PURE__ */ new Map();
+    this.participants = /* @__PURE__ */ new Map();
+    this.remoteStreams = /* @__PURE__ */ new Map();
+    this.trackToParticipant = /* @__PURE__ */ new Map();
+    this.trackToSource = /* @__PURE__ */ new Map();
+    this.localTrackIds = /* @__PURE__ */ new Map();
+    this.subscriberStatsTimer = null;
+    this.apiBase = options.apiBase || "https://api.example.com/api";
+    this.wsBase = options.wsBase || "wss://api.example.com/ws";
+    this.userId = options.userId || this.createId();
+    this.onStateChange = options.onStateChange || (() => {
+    });
+    this.onParticipantJoined = options.onParticipantJoined || (() => {
+    });
+    this.onParticipantLeft = options.onParticipantLeft || (() => {
+    });
+    this.onParticipantPresence = options.onParticipantPresence || (() => {
+    });
+    this.onTrackPublished = options.onTrackPublished || (() => {
+    });
+    this.onTrackUnpublished = options.onTrackUnpublished || (() => {
+    });
+    this.onRemoteTrack = options.onRemoteTrack || (() => {
+    });
+    this.onConnected = options.onConnected || (() => {
+    });
+    this.onDisconnected = options.onDisconnected || (() => {
+    });
+    this.onReconnecting = options.onReconnecting || (() => {
+    });
+    this.onJoinPending = options.onJoinPending || (() => {
+    });
+    this.onJoinApproved = options.onJoinApproved || (() => {
+    });
+    this.onJoinRejected = options.onJoinRejected || (() => {
+    });
+    this.onJoinRequested = options.onJoinRequested || (() => {
+    });
+    this.onScreenShareStarted = options.onScreenShareStarted || (() => {
+    });
+    this.onScreenShareStopped = options.onScreenShareStopped || (() => {
+    });
+    this.onTrackStateChanged = options.onTrackStateChanged || (() => {
+    });
+    this.onRecordingStarted = options.onRecordingStarted || (() => {
+    });
+    this.onRecordingStopped = options.onRecordingStopped || (() => {
+    });
+    this.onError = options.onError || console.error;
+    this.autoSubscribe = options.autoSubscribe !== false;
+  }
+  createId() {
+    return typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `id_${Math.random().toString(36).slice(2)}_${Date.now()}`;
+  }
+  resumeStorageKey(roomCode) {
+    return `defcomm:sfu:resume:${roomCode}`;
+  }
+  loadResumeToken(roomCode) {
+    try {
+      return localStorage.getItem(this.resumeStorageKey(roomCode));
+    } catch {
+      return null;
+    }
+  }
+  saveResumeToken(roomCode, token) {
+    try {
+      localStorage.setItem(this.resumeStorageKey(roomCode), token);
+    } catch {
+    }
+  }
+  clearResumeToken(roomCode) {
+    if (!roomCode) return;
+    try {
+      localStorage.removeItem(this.resumeStorageKey(roomCode));
+    } catch {
+    }
+  }
+  setState(next) {
+    if (this.state === next) return;
+    this.state = next;
+    this.onStateChange(next);
+  }
+  getConnectionState() {
+    return this.state;
+  }
+  getParticipantId() {
+    return this.currentParticipantId;
+  }
+  getResumeToken() {
+    return this.resumeToken;
+  }
+  getLocalStream() {
+    return this.localStream;
+  }
+  getScreenStream() {
+    return this.screenStream;
+  }
+  setLocalStream(stream) {
+    this.localStream = stream;
+  }
+  nextRequestId() {
+    return (++this.requestId).toString();
+  }
+  async request(url, options = {}) {
+    const res = await fetch(url, {
+      headers: { "Content-Type": "application/json" },
+      ...options
+    });
+    if (!res.ok) {
+      let body = {};
+      try {
+        body = await res.json();
+      } catch {
+      }
+      throw new Error(body.message || res.statusText);
+    }
+    return res.json();
+  }
+  async createRoom(input) {
+    return this.request(`${this.apiBase}/rooms`, {
+      method: "POST",
+      body: JSON.stringify({
+        name: input.name,
+        description: input.description ?? "",
+        capacity: input.capacity ?? 20,
+        is_private: input.is_private ?? false
+      })
+    });
+  }
+  async getRoom(roomCode) {
+    return this.request(`${this.apiBase}/rooms/${encodeURIComponent(roomCode)}`);
+  }
+  async deleteRoom(roomCode) {
+    return this.request(`${this.apiBase}/rooms/${encodeURIComponent(roomCode)}`, {
+      method: "DELETE"
+    });
+  }
+  async getToken(roomCode, options = {}) {
+    const nextRoom = roomCode.trim();
+    if (this.room && this.room !== nextRoom) {
+      this.resumeToken = null;
+    }
+    this.room = nextRoom;
+    this.joinOptions = {
+      displayName: options.displayName,
+      avatarUrl: options.avatarUrl
+    };
+    if (options.userId) this.userId = options.userId;
+    if (!this.resumeToken) {
+      this.resumeToken = this.loadResumeToken(this.room);
+    }
+    const data = await this.request(`${this.apiBase}/token`, {
+      method: "POST",
+      body: JSON.stringify({
+        room_code: this.room,
+        user_id: this.userId,
+        display_name: options.displayName,
+        avatar_url: options.avatarUrl
+      })
+    });
+    this.token = data?.token;
+    if (!this.token) throw new Error("Token endpoint returned no token");
+    return this.connect(this.token, this.joinOptions);
+  }
+  async refreshAccessToken() {
+    if (!this.room) throw new Error("Cannot refresh token without a room");
+    const data = await this.request(`${this.apiBase}/token`, {
+      method: "POST",
+      body: JSON.stringify({
+        room_code: this.room,
+        user_id: this.userId,
+        display_name: this.joinOptions.displayName,
+        avatar_url: this.joinOptions.avatarUrl
+      })
+    });
+    if (!data?.token) throw new Error("Token refresh returned no token");
+    this.token = data.token;
+    return this.token;
+  }
+  connect(token, options = {}) {
+    this.token = token;
+    this.intentionalClose = false;
+    this.setState(this.reconnectAttempt > 0 ? "reconnecting" : "connecting");
+    return new Promise((resolve, reject) => {
+      this.joinWaiter = { resolve, reject };
+      this.openWebSocket(options);
+    });
+  }
+  openWebSocket(options = {}) {
+    if (!this.token || !this.room) {
+      const error = new Error("Cannot connect without token and room");
+      this.failJoin(error);
+      return;
+    }
+    if (this.ws) {
+      try {
+        this.ws.onclose = null;
+        this.ws.close();
+      } catch {
+      }
+    }
+    const ws = new WebSocket(
+      `${this.wsBase}?access_token=${encodeURIComponent(this.token)}`
+    );
+    this.ws = ws;
+    ws.onopen = () => {
+      this.setState("joining");
+      this.joiningWithResume = Boolean(this.resumeToken);
+      const joinPayload = {
+        token: this.token,
+        room_code: this.room,
+        resume_token: this.resumeToken,
+        display_name: options.displayName,
+        avatar_url: options.avatarUrl
+      };
+      if (this.pendingJoinRequestId) {
+        this.send({
+          type: "join",
+          request_id: this.pendingJoinRequestId,
+          payload: joinPayload
+        });
+      } else {
+        this.send({ type: "join", payload: joinPayload });
+      }
+    };
+    ws.onerror = (event) => {
+      this.onError(event);
+    };
+    ws.onclose = () => {
+      if (this.ws !== ws) return;
+      this.ws = null;
+      if (this.intentionalClose || this.state === "leaving") {
+        this.setState("disconnected");
+        this.onDisconnected();
+        return;
+      }
+      this.setState("reconnecting");
+      this.onDisconnected();
+      this.scheduleReconnect();
+    };
+    ws.onmessage = async (event) => {
+      if (this.ws !== ws) return;
+      try {
+        const message = JSON.parse(event.data);
+        await this.handleServerMessage(message);
+      } catch (error) {
+        this.onError(error);
+      }
+    };
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer || this.intentionalClose) return;
+    if (this.reconnectAttempt >= this.maxReconnectAttempts) {
+      this.setState("disconnected");
+      this.failJoin(new Error("SFU reconnect attempts exhausted"));
+      return;
+    }
+    this.reconnectAttempt += 1;
+    const delay = Math.min(
+      15e3,
+      this.reconnectBaseMs * Math.pow(2, this.reconnectAttempt - 1)
+    );
+    this.onReconnecting(this.reconnectAttempt);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.refreshAccessToken();
+        this.openWebSocket(this.joinOptions);
+      } catch (error) {
+        this.onError(error);
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  failJoin(error) {
+    if (this.joinWaiter) {
+      const waiter = this.joinWaiter;
+      this.joinWaiter = null;
+      waiter.reject(error);
+    }
+  }
+  resolveJoin(value) {
+    if (!this.joinWaiter) return;
+    const waiter = this.joinWaiter;
+    this.joinWaiter = null;
+    waiter.resolve(value);
+  }
+  async handleServerMessage(message) {
+    const type = message?.type;
+    const payload = message?.payload || {};
+    switch (type) {
+      case "joined": {
+        await this.handleJoined(payload);
+        break;
+      }
+      case "left": {
+        this.leaveAcknowledged = true;
+        break;
+      }
+      case "join_pending": {
+        const requestId = payload.request_id || message.request_id;
+        if (!requestId) throw new Error("join_pending has no request_id");
+        this.pendingJoinRequestId = requestId;
+        this.setState("waiting_approval");
+        this.onJoinPending({
+          request_id: requestId,
+          room_code: payload.room_code || this.room || void 0,
+          message: payload.message
+        });
+        break;
+      }
+      case "join_approved": {
+        const requestId = payload.request_id || message.request_id;
+        if (!requestId) break;
+        this.pendingJoinRequestId = requestId;
+        this.onJoinApproved(requestId);
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          this.setState("joining");
+          this.send({
+            type: "join",
+            request_id: requestId,
+            payload: {
+              token: this.token,
+              room_code: this.room,
+              resume_token: this.resumeToken,
+              display_name: this.joinOptions.displayName,
+              avatar_url: this.joinOptions.avatarUrl
+            }
+          });
+        }
+        break;
+      }
+      case "join_rejected": {
+        const requestId = payload.request_id || message.request_id;
+        const reason = payload.reason;
+        this.onJoinRejected(requestId, reason);
+        this.pendingJoinRequestId = null;
+        this.intentionalClose = true;
+        this.failJoin(new Error(reason || "Join request rejected"));
+        break;
+      }
+      case "join_requested":
+      case "join_request": {
+        this.onJoinRequested(payload.request || payload);
+        break;
+      }
+      case "publish_answer": {
+        if (!this.publisher) break;
+        await this.publisher.setRemoteDescription({
+          type: "answer",
+          sdp: payload.sdp
+        });
+        await this.flushPendingIce("publisher");
+        break;
+      }
+      case "subscribe_offer": {
+        this.offerQueue.push(payload);
+        if (!this.subscriberNegotiating) await this.processOfferQueue();
+        break;
+      }
+      case "ice_candidate":
+      case "publisher_ice_candidate":
+      case "subscriber_ice_candidate": {
+        const candidatePayload = {
+          ...payload,
+          peer: payload.peer || (type === "publisher_ice_candidate" ? "publisher" : "subscriber")
+        };
+        await this.handleIce(candidatePayload);
+        break;
+      }
+      case "participant_joined": {
+        const participant = payload.participant || payload;
+        const participantId = participant?.participant_id || payload.participant_id;
+        if (!participantId || participantId === this.currentParticipantId) break;
+        if (participant) this.participants.set(participantId, participant);
+        this.onParticipantJoined(participant);
+        break;
+      }
+      case "participant_left": {
+        const participantId = payload.participant_id;
+        if (!participantId) break;
+        this.participants.delete(participantId);
+        this.removeRemoteParticipant(participantId);
+        this.onParticipantLeft(participantId);
+        break;
+      }
+      case "participant_presence":
+      case "participant_presence_changed": {
+        const participantId = payload.participant_id;
+        const presence = payload.presence;
+        if (participantId && presence) {
+          this.onParticipantPresence(participantId, String(presence));
+        }
+        break;
+      }
+      case "track_published": {
+        const track = payload.track || payload;
+        if (!track?.track_id) break;
+        this.rememberTrack(track);
+        if (track.participant_id === this.currentParticipantId) {
+          if (track.source === "audio") {
+            this.localTrackIds.set("audio", track.track_id);
+            const muted = !(this.localStream?.getAudioTracks()[0]?.enabled ?? true);
+            this.send({ type: "track_state", payload: { track_id: track.track_id, muted } });
+          }
+          if (track.source === "camera") {
+            this.localTrackIds.set("camera", track.track_id);
+            const muted = !(this.localStream?.getVideoTracks()[0]?.enabled ?? true);
+            this.send({ type: "track_state", payload: { track_id: track.track_id, muted } });
+          }
+          if (track.source === "screen") this.localTrackIds.set("screen", track.track_id);
+          break;
+        }
+        this.onTrackPublished(track);
+        if (this.autoSubscribe) await this.subscribe(track.track_id);
+        break;
+      }
+      case "track_unpublished": {
+        const trackId = payload.track_id || payload.track?.track_id;
+        if (!trackId) break;
+        const track = this.trackMetadata.get(trackId) || {
+          track_id: trackId,
+          participant_id: this.trackToParticipant.get(trackId) || "",
+          source: this.trackToSource.get(trackId),
+          kind: "video"
+        };
+        this.trackMetadata.delete(trackId);
+        this.subscribedTracks.delete(trackId);
+        this.trackToParticipant.delete(trackId);
+        this.trackToSource.delete(trackId);
+        for (const [source, localId] of this.localTrackIds) {
+          if (localId === trackId) this.localTrackIds.delete(source);
+        }
+        if (track.participant_id === this.currentParticipantId) break;
+        this.onTrackUnpublished(track);
+        break;
+      }
+      case "track_state_changed": {
+        const trackId = payload.track_id || payload.track?.track_id;
+        if (!trackId) break;
+        const existing = this.trackMetadata.get(trackId);
+        const track = {
+          ...existing || {},
+          ...payload.track || {},
+          track_id: trackId,
+          participant_id: payload.participant_id || existing?.participant_id || payload.track?.participant_id,
+          kind: payload.kind || payload.track?.kind || existing?.kind || "video",
+          source: payload.source || payload.track?.source || existing?.source,
+          muted: Boolean(payload.muted)
+        };
+        if (!track.participant_id) break;
+        this.rememberTrack(track);
+        this.onTrackStateChanged(track);
+        break;
+      }
+      case "subscription_updated": {
+        break;
+      }
+      case "recording_started": {
+        this.onRecordingStarted({
+          recording_id: payload.recording_id,
+          started_at: payload.started_at
+        });
+        break;
+      }
+      case "recording_stopped": {
+        this.onRecordingStopped({
+          recording_id: payload.recording_id,
+          stopped_at: payload.stopped_at
+        });
+        break;
+      }
+      case "reconnecting": {
+        this.setState("reconnecting");
+        break;
+      }
+      case "screen_share_started": {
+        const participantId = payload.participant_id;
+        const track = payload.track;
+        if (track) this.rememberTrack(track);
+        if (participantId) this.onScreenShareStarted(participantId, track);
+        break;
+      }
+      case "screen_share_stopped": {
+        const participantId = payload.participant_id;
+        const stream = participantId ? this.remoteStreams.get(participantId) : null;
+        const trackId = payload.track_id;
+        if (stream) {
+          for (const track of stream.getVideoTracks()) {
+            const source = this.trackToSource.get(this.normalizeRemoteTrackId(track.id));
+            if (!trackId || this.normalizeRemoteTrackId(track.id) === String(trackId) || source === "screen") {
+              stream.removeTrack(track);
+              track.stop();
+            }
+          }
+        }
+        this.onScreenShareStopped(participantId, trackId);
+        break;
+      }
+      case "error": {
+        const error = new Error(payload.message || "SFU signaling error");
+        this.onError(error);
+        if (this.state === "joining" || this.state === "waiting_approval") {
+          this.failJoin(error);
+        }
+        break;
+      }
+      default:
+        console.debug("[SFU] Ignoring unknown server message", message);
+    }
+  }
+  rememberTrack(track) {
+    this.trackMetadata.set(track.track_id, track);
+    this.trackToParticipant.set(track.track_id, track.participant_id);
+    if (track.source) this.trackToSource.set(track.track_id, track.source);
+  }
+  async handleJoined(payload) {
+    const resumed = this.joiningWithResume;
+    this.joiningWithResume = false;
+    this.iceServers = payload.ice_servers || this.iceServers || [];
+    this.currentParticipantId = payload.participant_id;
+    this.resumeToken = payload.resume_token || payload.resumeToken || this.resumeToken;
+    if (this.room && this.resumeToken) {
+      this.saveResumeToken(this.room, this.resumeToken);
+    }
+    this.pendingJoinRequestId = null;
+    this.reconnectAttempt = 0;
+    this.participants.clear();
+    this.trackMetadata.clear();
+    this.trackToParticipant.clear();
+    this.trackToSource.clear();
+    this.localTrackIds.clear();
+    for (const participant of payload.participants || []) {
+      if (participant?.participant_id) {
+        this.participants.set(participant.participant_id, participant);
+      }
+    }
+    for (const track of payload.tracks || []) {
+      if (track?.track_id) this.rememberTrack(track);
+    }
+    await this.initializePeerConnections();
+    this.setState("connected");
+    this.onConnected(payload, resumed);
+    for (const participant of this.participants.values()) {
+      if (participant.participant_id !== this.currentParticipantId) {
+        this.onParticipantJoined(participant);
+      }
+    }
+    if (this.localStream) {
+      await this.publishExistingTracks();
+    }
+    if (this.autoSubscribe) {
+      const trackIds = [...this.trackMetadata.values()].filter((track) => track.participant_id !== this.currentParticipantId).map((track) => track.track_id);
+      if (trackIds.length) await this.subscribeMultiple(trackIds);
+    }
+    this.resolveJoin(payload);
+  }
+  async initializePeerConnections() {
+    this.closePeerConnectionsOnly();
+    this.publisherRevision = 0;
+    const config = { iceServers: this.iceServers };
+    this.publisher = new RTCPeerConnection(config);
+    this.subscriber = new RTCPeerConnection(config);
+    this.publisher.onicecandidate = (event) => {
+      if (event.candidate) this.sendCandidate("publisher", event.candidate);
+    };
+    this.subscriber.onicecandidate = (event) => {
+      if (event.candidate) this.sendCandidate("subscriber", event.candidate);
+    };
+    this.publisher.onconnectionstatechange = () => {
+      const state = this.publisher?.connectionState;
+      if (state === "failed") {
+        this.onError(new Error("Publisher PeerConnection failed"));
+      }
+    };
+    this.subscriber.onconnectionstatechange = () => {
+      const state = this.subscriber?.connectionState;
+      if (state === "failed") {
+        this.onError(new Error("Subscriber PeerConnection failed"));
+      }
+    };
+    this.subscriber.ontrack = (event) => {
+      void this.handleRemoteTrack(event);
+    };
+    if (!this.subscriberStatsTimer) {
+      this.subscriberStatsTimer = setInterval(() => {
+        void this.logSubscriberVideoStats();
+      }, 3e3);
+    }
+  }
+  async handleRemoteTrack(event) {
+    const stream = event.streams?.[0] || null;
+    const metadata = this.resolveRemoteTrackMetadata(event.track, stream);
+    if (!metadata?.participant_id) {
+      this.onError(
+        new Error(
+          `Remote ${event.track.kind} track ${event.track.id} has no SFU participant mapping`
+        )
+      );
+      return;
+    }
+    const participantId = metadata.participant_id;
+    let remoteStream = this.remoteStreams.get(participantId);
+    if (!remoteStream) {
+      remoteStream = new MediaStream();
+      this.remoteStreams.set(participantId, remoteStream);
+    }
+    const source = metadata.source || this.trackToSource.get(metadata.track_id);
+    if (source === "screen") {
+      for (const existing of remoteStream.getVideoTracks()) {
+        if (existing.id !== event.track.id && this.trackToSource.get(existing.id) === "screen") {
+          remoteStream.removeTrack(existing);
+          existing.stop();
+        }
+      }
+    } else {
+      for (const existing of remoteStream.getTracks()) {
+        if (existing.kind === event.track.kind && existing.id !== event.track.id) {
+          remoteStream.removeTrack(existing);
+          existing.stop();
+        }
+      }
+    }
+    if (!remoteStream.getTracks().some((track) => track.id === event.track.id)) {
+      remoteStream.addTrack(event.track);
+    }
+    event.track.onended = () => {
+      try {
+        remoteStream?.removeTrack(event.track);
+      } catch {
+      }
+    };
+    if (source === "screen") {
+      this.onScreenShareStarted(participantId, metadata);
+    }
+    this.onRemoteTrack(event.track, remoteStream, metadata);
+  }
+  normalizeRemoteTrackId(browserTrackId) {
+    return browserTrackId?.startsWith("track-") ? browserTrackId.slice("track-".length) : browserTrackId;
+  }
+  resolveRemoteTrackMetadata(track, stream) {
+    const sfuTrackId = this.normalizeRemoteTrackId(track.id);
+    const exact = this.trackMetadata.get(sfuTrackId);
+    if (exact) return exact;
+    const byTrackId = this.trackMetadata.get(track.id);
+    if (byTrackId) return byTrackId;
+    const matching = [...this.trackMetadata.values()].find(
+      (entry) => entry.kind === track.kind
+    );
+    if (matching) return matching;
+    if (stream?.id) {
+      const participant = this.participants.get(stream.id);
+      if (participant) {
+        return [...this.trackMetadata.values()].find(
+          (entry) => entry.participant_id === participant.participant_id && entry.kind === track.kind
+        ) || null;
+      }
+    }
+    return null;
+  }
+  sendCandidate(peer, candidate) {
+    this.send({
+      type: "ice_candidate",
+      payload: {
+        peer,
+        candidate: candidate.candidate,
+        sdp_mid: candidate.sdpMid,
+        sdp_mline_index: candidate.sdpMLineIndex,
+        username_fragment: candidate.usernameFragment
+      }
+    });
+  }
+  async handleIce(payload) {
+    const peer = payload.peer === "publisher" ? "publisher" : "subscriber";
+    const pc = peer === "publisher" ? this.publisher : this.subscriber;
+    const candidate = {
+      candidate: payload.candidate,
+      sdpMid: payload.sdp_mid ?? payload.sdpMid ?? null,
+      sdpMLineIndex: payload.sdp_mline_index ?? payload.sdpMLineIndex ?? null,
+      usernameFragment: payload.username_fragment ?? payload.usernameFragment ?? null
+    };
+    if (!pc || !pc.remoteDescription) {
+      this.pendingIce[peer].push(candidate);
+      return;
+    }
+    try {
+      await pc.addIceCandidate(candidate);
+    } catch (error) {
+      this.onError(new Error(`Failed to add ${peer} ICE candidate: ${String(error)}`));
+    }
+  }
+  async flushPendingIce(peer) {
+    const pc = peer === "publisher" ? this.publisher : this.subscriber;
+    if (!pc || !pc.remoteDescription) return;
+    const queue = this.pendingIce[peer];
+    while (queue.length) {
+      const candidate = queue.shift();
+      try {
+        await pc.addIceCandidate(candidate);
+      } catch (error) {
+        this.onError(new Error(`Failed to add queued ${peer} ICE candidate: ${String(error)}`));
+      }
+    }
+  }
+  async processOfferQueue() {
+    if (!this.subscriber) return;
+    while (this.offerQueue.length) {
+      if (this.subscriberNegotiating) return;
+      this.subscriberNegotiating = true;
+      const offer = this.offerQueue.shift();
+      try {
+        await this.subscriber.setRemoteDescription({
+          type: "offer",
+          sdp: offer.sdp
+        });
+        await this.flushPendingIce("subscriber");
+        const answer = await this.subscriber.createAnswer();
+        await this.subscriber.setLocalDescription(answer);
+        this.send({
+          type: "subscribe_answer",
+          payload: {
+            revision: offer.revision,
+            sdp: answer.sdp
+          }
+        });
+        const waiters = this.subscriptionWaiters.splice(0);
+        waiters.forEach((w) => w.resolve());
+      } catch (error) {
+        const waiters = this.subscriptionWaiters.splice(0);
+        waiters.forEach((w) => w.reject(error));
+        this.onError(new Error(`Failed to process subscriber offer: ${String(error)}`));
+      } finally {
+        this.subscriberNegotiating = false;
+      }
+    }
+  }
+  async subscribe(trackId) {
+    if (!trackId || this.subscribedTracks.has(trackId)) return;
+    this.subscribedTracks.add(trackId);
+    this.subscriptionQueue.push(trackId);
+    if (!this.subscriptionRunning) await this.processSubscriptionQueue();
+  }
+  async subscribeMultiple(trackIds) {
+    const uniqueIds = [...new Set(trackIds.filter(Boolean))].filter(
+      (id) => !this.subscribedTracks.has(id)
+    );
+    if (!uniqueIds.length || !this.isSocketOpen()) return;
+    uniqueIds.forEach((id) => this.subscribedTracks.add(id));
+    return new Promise((resolve, reject) => {
+      this.subscriptionWaiters.push({ resolve, reject });
+      this.send({
+        type: "subscribe",
+        payload: { track_ids: uniqueIds }
+      });
+    });
+  }
+  async processSubscriptionQueue() {
+    this.subscriptionRunning = true;
+    try {
+      while (this.subscriptionQueue.length) {
+        const trackId = this.subscriptionQueue.shift();
+        if (!this.isSocketOpen()) {
+          this.subscribedTracks.delete(trackId);
+          continue;
+        }
+        await new Promise((resolve, reject) => {
+          this.subscriptionWaiters.push({ resolve, reject });
+          this.send({
+            type: "subscribe",
+            payload: { track_ids: [trackId] }
+          });
+        });
+      }
+    } finally {
+      this.subscriptionRunning = false;
+    }
+  }
+  async publish({ audio = true, video = true } = {}) {
+    if (!this.publisher) throw new Error("Publisher PeerConnection is not initialized");
+    if (!this.localStream) {
+      this.localStream = await navigator.mediaDevices.getUserMedia({ audio, video });
+    }
+    await this.publishExistingTracks(audio, video);
+    return this.localStream;
+  }
+  async publishExistingTracks(audio = true, video = true) {
+    if (!this.publisher || !this.localStream) return;
+    this.audioSender = null;
+    this.videoSender = null;
+    for (const track of this.localStream.getTracks()) {
+      if (track.kind === "audio" && !audio) continue;
+      if (track.kind === "video" && !video) continue;
+      const sender = this.publisher.addTrack(track, this.localStream);
+      if (track.kind === "audio") this.audioSender = sender;
+      if (track.kind === "video") this.videoSender = sender;
+    }
+    if (this.screenStream?.getVideoTracks()[0]) {
+      const screenTrack = this.screenStream.getVideoTracks()[0];
+      this.screenSender = this.publisher.addTrack(screenTrack, this.screenStream);
+    }
+    if (!this.publisher.getSenders().length) return;
+    const offer = await this.publisher.createOffer();
+    await this.publisher.setLocalDescription(offer);
+    this.send({
+      type: "publish_offer",
+      payload: {
+        revision: ++this.publisherRevision,
+        sdp: offer.sdp
+      }
+    });
+    if (this.screenStream?.getVideoTracks()[0]) {
+      this.send({ type: "start_screen_share" });
+    }
+  }
+  async shareScreen() {
+    if (!this.publisher) throw new Error("Publisher PeerConnection is not initialized");
+    if (this.screenStream) return this.screenStream;
+    this.screenStream = await navigator.mediaDevices.getDisplayMedia({ video: true });
+    const screenTrack = this.screenStream.getVideoTracks()[0];
+    if (!screenTrack) throw new Error("Screen share returned no video track");
+    this.screenSender = this.publisher.addTrack(screenTrack, this.screenStream);
+    const offer = await this.publisher.createOffer();
+    await this.publisher.setLocalDescription(offer);
+    this.send({
+      type: "publish_offer",
+      payload: {
+        revision: ++this.publisherRevision,
+        sdp: offer.sdp
+      }
+    });
+    this.send({ type: "start_screen_share" });
+    screenTrack.onended = () => {
+      void this.stopScreenShare();
+    };
+    return this.screenStream;
+  }
+  async stopScreenShare() {
+    if (!this.screenStream) return;
+    const screenTrack = this.screenStream.getVideoTracks()[0];
+    if (screenTrack) screenTrack.onended = null;
+    if (this.screenSender && this.publisher) {
+      try {
+        this.publisher.removeTrack(this.screenSender);
+      } catch {
+      }
+      this.screenSender = null;
+      try {
+        const offer = await this.publisher.createOffer();
+        await this.publisher.setLocalDescription(offer);
+        this.send({
+          type: "publish_offer",
+          payload: {
+            revision: ++this.publisherRevision,
+            sdp: offer.sdp
+          }
+        });
+        this.send({ type: "stop_screen_share" });
+      } catch (error) {
+        this.onError(error);
+      }
+    }
+    this.screenStream.getTracks().forEach((track) => track.stop());
+    this.screenStream = null;
+  }
+  muteAudio(muted) {
+    this.localStream?.getAudioTracks().forEach((track) => {
+      track.enabled = !muted;
+    });
+    const trackId = this.localTrackIds.get("audio");
+    if (trackId) {
+      this.send({
+        type: "track_state",
+        payload: {
+          track_id: trackId,
+          muted
+        }
+      });
+    }
+  }
+  muteVideo(muted) {
+    this.localStream?.getVideoTracks().forEach((track) => {
+      track.enabled = !muted;
+    });
+    const trackId = this.localTrackIds.get("camera");
+    if (trackId) {
+      this.send({
+        type: "track_state",
+        payload: {
+          track_id: trackId,
+          muted
+        }
+      });
+    }
+  }
+  async startRecording() {
+    if (!this.send({ type: "start_recording" })) {
+      throw new Error("SFU signaling is not connected");
+    }
+  }
+  async stopRecording() {
+    if (!this.send({ type: "stop_recording" })) {
+      throw new Error("SFU signaling is not connected");
+    }
+  }
+  async getRecordingStatus() {
+    if (!this.room || !this.token) {
+      throw new Error("SFU client is not connected");
+    }
+    return this.request(
+      `${this.apiBase}/rooms/${encodeURIComponent(this.room)}/recording`,
+      {
+        headers: {
+          Authorization: `Bearer ${this.token}`
+        }
+      }
+    );
+  }
+  async approveJoinRequest(requestId) {
+    if (!requestId) throw new Error("requestId is required");
+    if (!this.send({ type: "approve_join", payload: { request_id: requestId } })) {
+      throw new Error("SFU signaling is not connected");
+    }
+  }
+  async rejectJoinRequest(requestId, reason) {
+    if (!requestId) throw new Error("requestId is required");
+    if (!this.send({ type: "reject_join", payload: { request_id: requestId, reason } })) {
+      throw new Error("SFU signaling is not connected");
+    }
+  }
+  isSocketOpen() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  send(message) {
+    if (!this.isSocketOpen()) return false;
+    this.ws.send(
+      JSON.stringify({
+        request_id: this.nextRequestId(),
+        ...message
+      })
+    );
+    return true;
+  }
+  removeRemoteParticipant(participantId) {
+    const stream = this.remoteStreams.get(participantId);
+    if (stream) {
+      stream.getTracks().forEach((track) => track.stop());
+      this.remoteStreams.delete(participantId);
+    }
+    for (const [trackId, metadata] of this.trackMetadata) {
+      if (metadata.participant_id === participantId) {
+        this.trackMetadata.delete(trackId);
+        this.subscribedTracks.delete(trackId);
+        this.trackToParticipant.delete(trackId);
+        this.trackToSource.delete(trackId);
+      }
+    }
+  }
+  async leave() {
+    this.intentionalClose = true;
+    this.setState("leaving");
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    const roomCode = this.room;
+    const ws = this.ws;
+    this.leaveAcknowledged = false;
+    if (ws?.readyState === WebSocket.OPEN) {
+      await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+          if (settled) return;
+          settled = true;
+          resolve();
+        };
+        const timeout = setTimeout(finish, 1200);
+        const check = () => {
+          if (this.leaveAcknowledged || this.ws !== ws) {
+            clearTimeout(timeout);
+            finish();
+            return;
+          }
+          if (ws.readyState !== WebSocket.OPEN) {
+            clearTimeout(timeout);
+            finish();
+            return;
+          }
+          setTimeout(check, 25);
+        };
+        ws.addEventListener("close", () => {
+          clearTimeout(timeout);
+          finish();
+        }, { once: true });
+        this.send({ type: "leave" });
+        check();
+      });
+      try {
+        ws.close(1e3, "client_leave");
+      } catch {
+      }
+    }
+    this.clearResumeToken(roomCode);
+    this.cleanupAll();
+    this.setState("disconnected");
+  }
+  closePeerConnectionsOnly() {
+    if (this.publisher) {
+      try {
+        this.publisher.close();
+      } catch {
+      }
+      this.publisher = null;
+    }
+    if (this.subscriber) {
+      try {
+        this.subscriber.close();
+      } catch {
+      }
+      this.subscriber = null;
+    }
+    this.videoSender = null;
+    this.audioSender = null;
+    this.screenSender = null;
+    this.pendingIce = { publisher: [], subscriber: [] };
+    this.offerQueue = [];
+    this.subscriberNegotiating = false;
+    this.subscriptionQueue = [];
+    this.subscriptionRunning = false;
+    this.subscriptionWaiters.splice(0).forEach((w) => w.reject(new Error("PeerConnection recreated")));
+    this.subscribedTracks.clear();
+  }
+  cleanupAll() {
+    if (this.subscriberStatsTimer) {
+      clearInterval(this.subscriberStatsTimer);
+      this.subscriberStatsTimer = null;
+    }
+    this.closePeerConnectionsOnly();
+    this.localStream?.getTracks().forEach((track) => track.stop());
+    this.screenStream?.getTracks().forEach((track) => track.stop());
+    this.localStream = null;
+    this.screenStream = null;
+    for (const stream of this.remoteStreams.values()) {
+      stream.getTracks().forEach((track) => track.stop());
+    }
+    this.remoteStreams.clear();
+    this.trackMetadata.clear();
+    this.trackToParticipant.clear();
+    this.trackToSource.clear();
+    this.localTrackIds.clear();
+    this.participants.clear();
+    this.currentParticipantId = null;
+    this.resumeToken = null;
+    this.pendingJoinRequestId = null;
+    this.token = null;
+    this.room = null;
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+  }
+  async logSubscriberVideoStats() {
+    if (!this.subscriber || this.subscriber.connectionState === "closed") return;
+    try {
+      const stats = await this.subscriber.getStats();
+      stats.forEach((report) => {
+        if (report.type === "inbound-rtp" && (report.kind === "video" || report.mediaType === "video")) {
+          console.debug("[SFU] subscriber video", {
+            packetsReceived: report.packetsReceived,
+            packetsLost: report.packetsLost,
+            framesDecoded: report.framesDecoded,
+            frameWidth: report.frameWidth,
+            frameHeight: report.frameHeight
+          });
+        }
+      });
+    } catch {
+    }
+  }
+};
+
+// 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") {
+    this.events = events;
+    this.apiBase = apiBase;
+    this.wsBase = wsBase;
+    this.sfuClient = null;
+    this.room = {
+      id: null,
+      name: null
+    };
+    this.localStream = null;
+    this.screenStream = null;
+    this.isScreenSharing = false;
+    this.participantName = "";
+    this.intentionalDisconnect = false;
+    this.remoteStreams = /* @__PURE__ */ new Map();
+    this.remoteScreenStreams = /* @__PURE__ */ new Map();
+    this.state = new MeetingState();
+    this.events = events;
+    let storedId = null;
+    try {
+      storedId = typeof localStorage !== "undefined" ? localStorage.getItem("defcomm:participant_id") : null;
+    } catch {
+    }
+    this.myId = storedId || (typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `user_${Date.now()}`);
+    try {
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem("defcomm:participant_id", this.myId);
+      }
+    } catch {
+    }
+  }
+  emitError(code, message, raw, recoverable = true) {
+    const err = {
+      code,
+      message,
+      raw,
+      roomId: this.room.id,
+      userId: this.myId,
+      recoverable
+    };
+    this.events.onError?.(err);
+    console.error("[MeetingSDK Error]", err);
+  }
+  // ============ LOCAL MEDIA ============
+  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.updateLocalMedia();
+    } catch (err) {
+      this.emitError("GET_USER_MEDIA_FAILED", err?.message, err, false);
+      throw err;
+    }
+  }
+  updateLocalMedia(audioMuted = false, videoMuted = false) {
+    if (!this.localStream) return;
+    this.state.updateLocalParticipant({
+      id: this.myId,
+      name: this.participantName,
+      media: {
+        stream: this.localStream,
+        cameraTrack: this.localStream.getVideoTracks()[0],
+        audioTrack: this.localStream.getAudioTracks()[0],
+        micEnabled: this.localStream.getAudioTracks()[0]?.enabled ?? !audioMuted,
+        camEnabled: this.localStream.getVideoTracks()[0]?.enabled ?? !videoMuted,
+        isScreenSharing: this.isScreenSharing,
+        screenStream: this.screenStream,
+        screenTrack: this.screenStream?.getVideoTracks()[0]
+      }
+    });
+    this.state.localStream = this.localStream;
+  }
+  // ============ CONNECTION / SIGNALLING ============
+  async createRoom(input) {
+    const client = this.sfuClient ?? new SFUClient({
+      apiBase: this.apiBase,
+      wsBase: this.wsBase,
+      userId: this.myId
+    });
+    return client.createRoom(input);
+  }
+  async getRoom(roomCode) {
+    const client = this.sfuClient ?? new SFUClient({
+      apiBase: this.apiBase,
+      wsBase: this.wsBase,
+      userId: this.myId
+    });
+    return client.getRoom(roomCode);
+  }
+  async deleteRoom(roomCode) {
+    const client = this.sfuClient ?? new SFUClient({
+      apiBase: this.apiBase,
+      wsBase: this.wsBase,
+      userId: this.myId
+    });
+    return client.deleteRoom(roomCode);
+  }
+  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.intentionalDisconnect = false;
+    this.participantName = name;
+    this.room.id = roomId;
+    this.room.name = name;
+    if (!this.localStream) {
+      this.localStream = await navigator.mediaDevices.getUserMedia({
+        video: true,
+        audio: true
+      });
+    }
+    this.localStream.getAudioTracks().forEach((track) => {
+      track.enabled = !audioMuted;
+    });
+    this.localStream.getVideoTracks().forEach((track) => {
+      track.enabled = !videoMuted;
+    });
+    this.updateLocalMedia(audioMuted, videoMuted);
+    return this.connect(roomId, name);
+  }
+  async connect(roomId, name) {
+    if (this.sfuClient) {
+      await this.sfuClient.leave();
+      this.sfuClient = null;
+    }
+    const client = new SFUClient({
+      apiBase: this.apiBase,
+      wsBase: this.wsBase,
+      userId: this.myId,
+      autoSubscribe: true,
+      onStateChange: (state) => this.handleSFUState(state),
+      onConnected: (payload, resumed) => {
+        console.log(
+          `[SFU] ${resumed ? "Resumed" : "Joined"} room`,
+          payload
+        );
+        this.state.updateLocalParticipant({
+          id: this.myId,
+          name: this.participantName
+        });
+      },
+      onDisconnected: () => {
+        console.log("[SFU] Signaling WebSocket disconnected; reconnecting");
+      },
+      onReconnecting: (attempt) => {
+        console.warn(`[SFU] Reconnecting, attempt ${attempt}`);
+      },
+      onJoinPending: (info) => {
+        console.log("[SFU] Join request pending", info);
+        this.events.onEntryRequested?.({
+          requestId: info.request_id,
+          userId: this.myId,
+          name: this.participantName
+        });
+      },
+      onJoinApproved: (requestId) => {
+        console.log("[SFU] Join approved", requestId);
+        this.events.onJoinApproved?.(requestId);
+        this.events.onEntryResponded?.(
+          { participantId: this.myId, decision: "approved" },
+          "approved"
+        );
+      },
+      onJoinRejected: (requestId, reason) => {
+        console.warn("[SFU] Join rejected", requestId, reason);
+        this.events.onJoinRejected?.(requestId);
+        this.events.onEntryResponded?.(
+          { participantId: this.myId, decision: "rejected" },
+          "rejected"
+        );
+        this.emitError(
+          "JOIN_REJECTED",
+          reason || "Your request to join was rejected",
+          { requestId, reason },
+          false
+        );
+      },
+      onJoinRequested: (request) => {
+        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;
+        this.events.onEntryRequested?.({
+          requestId,
+          userId,
+          name: nameValue
+        });
+      },
+      onParticipantJoined: (participant) => {
+        const pid = participant.participant_id;
+        if (!pid || pid === this.myId) return;
+        const pname = participant.user_metadata?.name || participant.display_name || "Participant";
+        this.state.addParticipant({
+          id: pid,
+          name: pname,
+          connectionState: "connected",
+          media: {
+            micEnabled: true,
+            camEnabled: true,
+            isScreenSharing: false,
+            stream: null
+          }
+        });
+        this.events.onUserJoined?.({
+          id: pid,
+          name: pname
+        });
+      },
+      onParticipantPresence: (participantId, presence) => {
+        if (participantId === this.myId) return;
+        const current = this.state.getParticipant(participantId);
+        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
+        });
+        const next = new Map(this.state.participants);
+        next.set(participantId, {
+          ...current,
+          connectionState
+        });
+        this.state.participants = next;
+        this.state.notify(`participant:${participantId}`);
+        this.state.notify("participants");
+      },
+      onParticipantLeft: (participant) => {
+        const pid = typeof participant === "string" ? participant : participant.participant_id;
+        if (!pid) return;
+        console.log("[SFU] Participant permanently left", pid);
+        this.cleanupRemoteParticipant(pid);
+        this.state.removeParticipant(pid);
+        this.events.onUserLeft?.(pid);
+      },
+      onTrackPublished: (track) => {
+        console.log("[SFU] Track published", track);
+      },
+      onTrackUnpublished: (track) => {
+        console.log("[SFU] Track unpublished", track);
+        const pid = track.participant_id;
+        if (!pid) return;
+        const current = this.state.getParticipant(pid);
+        if (track.source === "screen") {
+          const screen = this.remoteScreenStreams.get(pid);
+          screen?.getTracks().forEach((t) => t.stop());
+          this.remoteScreenStreams.delete(pid);
+          this.state.updateParticipantMedia(pid, {
+            isScreenSharing: false,
+            screenStream: null,
+            screenTrack: void 0
+          });
+          this.events.onScreenShareStopped?.(pid);
+          return;
+        }
+        if (!current) return;
+        this.state.updateParticipantMedia(pid, {
+          stream: current.media?.stream ?? null,
+          micEnabled: track.kind === "audio" ? false : current.media?.micEnabled ?? true,
+          camEnabled: track.kind === "video" ? false : current.media?.camEnabled ?? true
+        });
+      },
+      onTrackStateChanged: (track) => {
+        const pid = track.participant_id;
+        if (!pid || pid === this.myId) return;
+        const current = this.state.getParticipant(pid);
+        if (!current) return;
+        if (track.source === "audio") {
+          this.state.updateParticipantMedia(pid, {
+            stream: current.media?.stream ?? null,
+            micEnabled: !track.muted
+          });
+          this.events.onMuteStateChanged?.(pid, "audio", track.muted);
+        } else if (track.source === "camera") {
+          this.state.updateParticipantMedia(pid, {
+            stream: current.media?.stream ?? null,
+            camEnabled: !track.muted
+          });
+          this.events.onMuteStateChanged?.(pid, "video", track.muted);
+        }
+        this.events.onTrackStateChanged?.(track);
+      },
+      onRecordingStarted: (recording) => {
+        this.events.onRecordingStarted?.(recording);
+      },
+      onRecordingStopped: (recording) => {
+        this.events.onRecordingStopped?.(recording);
+      },
+      onRemoteTrack: (track, stream, metadata) => {
+        this.handleRemoteTrack(track, stream, metadata);
+      },
+      onScreenShareStarted: (participantId, track) => {
+        if (participantId === this.myId) return;
+        console.log("[SFU] Screen share started", participantId, track);
+        const current = this.state.getParticipant(participantId);
+        if (current) {
+          this.state.updateParticipantMedia(participantId, {
+            isScreenSharing: true,
+            screenStream: current.media?.screenStream ?? null
+          });
+        }
+      },
+      onScreenShareStopped: (participantId) => {
+        if (participantId === this.myId) return;
+        const screen = this.remoteScreenStreams.get(participantId);
+        screen?.getTracks().forEach((track) => track.stop());
+        this.remoteScreenStreams.delete(participantId);
+        this.state.updateParticipantMedia(participantId, {
+          isScreenSharing: false,
+          screenStream: null,
+          screenTrack: void 0
+        });
+        this.events.onScreenShareStopped?.(participantId);
+      },
+      onError: (error) => {
+        console.error("[SFU] Error:", error);
+        this.emitError("SFU_ERROR", error?.message || String(error), error, true);
+      }
+    });
+    this.sfuClient = client;
+    client.setLocalStream(this.localStream);
+    return client.getToken(roomId, {
+      displayName: name,
+      userId: this.myId
+    });
+  }
+  handleSFUState(state) {
+    this.events.onConnectionStateChanged?.(state);
+    if (state === "reconnecting") {
+      this.state.updateLocalParticipant({
+        id: this.myId,
+        name: this.participantName
+      });
+      return;
+    }
+    if (state === "disconnected" && !this.intentionalDisconnect) {
+      this.emitError(
+        "CONNECTION_LOST",
+        "Unable to reconnect to SFU server",
+        null,
+        true
+      );
+    }
+  }
+  handleRemoteTrack(track, stream, metadata) {
+    const participantId = metadata?.participant_id;
+    if (!participantId || participantId === this.myId) return;
+    const source = metadata.source;
+    if (source === "screen") {
+      let screenStream = this.remoteScreenStreams.get(participantId);
+      if (!screenStream) {
+        screenStream = new MediaStream();
+        this.remoteScreenStreams.set(participantId, screenStream);
+      }
+      for (const old of screenStream.getVideoTracks()) {
+        if (old.id !== track.id) {
+          screenStream.removeTrack(old);
+          old.stop();
+        }
+      }
+      if (!screenStream.getTracks().some((t) => t.id === track.id)) {
+        screenStream.addTrack(track);
+      }
+      this.state.updateParticipantMedia(participantId, {
+        screenStream,
+        screenTrack: track,
+        isScreenSharing: true
+      });
+      this.events.onScreenShareStarted?.(participantId, screenStream);
+      return;
+    }
+    let remoteStream = this.remoteStreams.get(participantId);
+    if (!remoteStream) {
+      remoteStream = new MediaStream();
+      this.remoteStreams.set(participantId, remoteStream);
+    }
+    for (const old of remoteStream.getTracks()) {
+      if (old.kind === track.kind && old.id !== track.id) {
+        remoteStream.removeTrack(old);
+        old.stop();
+      }
+    }
+    if (!remoteStream.getTracks().some((t) => t.id === track.id)) {
+      remoteStream.addTrack(track);
+    }
+    const current = this.state.getParticipant(participantId);
+    this.state.updateParticipantMedia(participantId, {
+      stream: remoteStream,
+      cameraTrack: track.kind === "video" ? track : current?.media?.cameraTrack,
+      audioTrack: track.kind === "audio" ? track : current?.media?.audioTrack
+    });
+    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
+      });
+    };
+  }
+  getMeeting() {
+    return this.room;
+  }
+  // ============ ADMISSION CONTROL ============
+  async approveJoinRequest(requestId) {
+    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");
+    return this.sfuClient.rejectJoinRequest(requestId, reason);
+  }
+  // ============ MEDIA CONTROL ============
+  toggleMic() {
+    const mediaState = this.state.localParticipant?.media;
+    if (!mediaState || !this.localStream) return;
+    const nextEnabled = !mediaState.micEnabled;
+    this.localStream.getAudioTracks().forEach((track) => {
+      track.enabled = nextEnabled;
+    });
+    this.state.updateLocalParticipant({
+      id: this.myId,
+      name: this.participantName,
+      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;
+    const nextEnabled = !mediaState.camEnabled;
+    this.localStream.getVideoTracks().forEach((track) => {
+      track.enabled = nextEnabled;
+    });
+    this.state.updateLocalParticipant({
+      id: this.myId,
+      name: this.participantName,
+      media: { camEnabled: nextEnabled }
+    });
+    this.sfuClient?.muteVideo(!nextEnabled);
+    this.events.onCamToggled?.(this.myId, nextEnabled);
+  }
+  // ============ SCREEN SHARING ============
+  async startScreenShare() {
+    try {
+      if (!navigator.mediaDevices?.getDisplayMedia) {
+        throw new Error("Screen sharing not supported on this device");
+      }
+      if (!this.sfuClient) {
+        throw new Error("Cannot share screen before joining the meeting");
+      }
+      this.screenStream = await this.sfuClient.shareScreen();
+      this.isScreenSharing = true;
+      this.state.updateLocalParticipant({
+        media: {
+          isScreenSharing: true,
+          screenStream: this.screenStream,
+          screenTrack: this.screenStream.getVideoTracks()[0]
+        }
+      });
+      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;
+    void this.sfuClient?.stopScreenShare();
+    this.screenStream.getTracks().forEach((track) => track.stop());
+    this.screenStream = null;
+    this.isScreenSharing = false;
+    this.state.updateLocalParticipant({
+      media: {
+        isScreenSharing: false,
+        screenStream: null,
+        screenTrack: void 0
+      }
+    });
+  }
+  // ============ RECORDING ============
+  async startRecording() {
+    if (!this.sfuClient) {
+      throw new Error("SFU client is not connected");
+    }
+    await this.sfuClient.startRecording();
+  }
+  async stopRecording() {
+    if (!this.sfuClient) {
+      throw new Error("SFU client is not connected");
+    }
+    await this.sfuClient.stopRecording();
+  }
+  async getRecordingStatus() {
+    if (!this.sfuClient) {
+      throw new Error("SFU client is not connected");
+    }
+    return this.sfuClient.getRecordingStatus();
+  }
+  // ============ CHAT ============
+  sendChatMessage(payload) {
+    if (!this.sfuClient) {
+      console.warn("SFU Client not connected");
+      return;
+    }
+    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.events.onChatMessage?.(msg);
+  }
+  // ============ CLEANUP ============
+  cleanupRemoteParticipant(participantId) {
+    const stream = this.remoteStreams.get(participantId);
+    stream?.getTracks().forEach((track) => track.stop());
+    this.remoteStreams.delete(participantId);
+    const screen = this.remoteScreenStreams.get(participantId);
+    screen?.getTracks().forEach((track) => track.stop());
+    this.remoteScreenStreams.delete(participantId);
+  }
+  async disconnect() {
+    this.intentionalDisconnect = true;
+    await this.sfuClient?.leave();
+    this.sfuClient = null;
+    if (this.localStream) {
+      this.localStream.getTracks().forEach((track) => track.stop());
+      this.localStream = null;
+    }
+    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());
+    }
+    this.remoteStreams.clear();
+    for (const stream of this.remoteScreenStreams.values()) {
+      stream.getTracks().forEach((track) => track.stop());
+    }
+    this.remoteScreenStreams.clear();
+    this.room.id = null;
+    this.room.name = null;
+    this.state.localParticipant = null;
+    this.state.notify("localParticipant");
+    this.state.resetRemoteState();
+    this.events.onMeetingLeft?.();
+  }
+};
+
+// src/react/useMeetingStore.ts
+var import_react = require("react");
+function useMeetingStore(stateManager, scope, selector) {
+  const [state, setState] = (0, import_react.useState)(() => selector(stateManager));
+  (0, import_react.useEffect)(() => {
+    const unsubscribe = stateManager.subscribe(scope, () => {
+      setState(selector(stateManager));
+    });
+    return unsubscribe;
+  }, [stateManager, scope, selector]);
+  return state;
+}
+
+// src/react/MeetingProvider.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var MeetingContext = (0, import_react2.createContext)(null);
+var MeetingProvider = ({
+  config,
+  children
+}) => {
+  const sdkRef = (0, import_react2.useRef)(null);
+  const errorListeners = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const entryRequestListeners = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  const entryResponseListeners = (0, import_react2.useRef)(
+    /* @__PURE__ */ new Set()
+  );
+  const meetingLeftListeners = (0, import_react2.useRef)(/* @__PURE__ */ new Set());
+  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());
+  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()),
+      onTrackStateChanged: (track) => trackStateListeners.current.forEach((fn) => fn(track)),
+      onRecordingStarted: (recording) => recordingStartedListeners.current.forEach((fn) => fn(recording)),
+      onRecordingStopped: (recording) => recordingStoppedListeners.current.forEach((fn) => fn(recording))
+    });
+  }
+  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 = (0, import_react2.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(),
+      createRoom: sdk.createRoom.bind(sdk),
+      getRoom: sdk.getRoom.bind(sdk),
+      deleteRoom: sdk.deleteRoom.bind(sdk),
+      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),
+      startRecording: sdk.startRecording.bind(sdk),
+      stopRecording: sdk.stopRecording.bind(sdk),
+      getRecordingStatus: sdk.getRecordingStatus.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);
+        };
+      },
+      onTrackStateChanged: (cb) => {
+        trackStateListeners.current.add(cb);
+        return () => trackStateListeners.current.delete(cb);
+      },
+      onRecordingStarted: (cb) => {
+        recordingStartedListeners.current.add(cb);
+        return () => recordingStartedListeners.current.delete(cb);
+      },
+      onRecordingStopped: (cb) => {
+        recordingStoppedListeners.current.add(cb);
+        return () => recordingStoppedListeners.current.delete(cb);
+      }
+    };
+  }, [config, sdk, localParticipant, participants, messages, presenterId]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(MeetingContext.Provider, { value, children });
+};
+var useMeetingContext = () => {
+  const ctx = (0, import_react2.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] = (0, import_react3.useState)(
+    () => {
+      const current = sdk.state.localParticipant;
+      return current && current.id ? current : null;
+    }
+  );
+  (0, import_react3.useEffect)(() => {
+    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 = (0, import_react3.useRef)(null);
+  const videoRef = (0, import_react3.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
+var import_react4 = require("react");
+var useMeeting = (handlers) => {
+  const ctx = useMeetingContext();
+  (0, import_react4.useEffect)(() => {
+    if (!handlers?.onError) return;
+    return ctx.onError(handlers.onError);
+  }, [handlers?.onError]);
+  (0, import_react4.useEffect)(() => {
+    if (!handlers?.onEntryRequested) return;
+    return ctx.onEntryRequested(handlers.onEntryRequested);
+  }, [handlers?.onEntryRequested]);
+  (0, import_react4.useEffect)(() => {
+    if (!handlers?.onEntryResponded) return;
+    return ctx.onEntryResponded(handlers.onEntryResponded);
+  }, [handlers?.onEntryResponded]);
+  (0, import_react4.useEffect)(() => {
+    if (!handlers?.onMeetingLeft) return;
+    return ctx.onMeetingLeft(handlers.onMeetingLeft);
+  }, [handlers?.onMeetingLeft]);
+  (0, import_react4.useEffect)(() => {
+    if (!handlers?.onTrackStateChanged) return;
+    return ctx.onTrackStateChanged(handlers.onTrackStateChanged);
+  }, [handlers?.onTrackStateChanged]);
+  (0, import_react4.useEffect)(() => {
+    if (!handlers?.onRecordingStarted) return;
+    return ctx.onRecordingStarted(handlers.onRecordingStarted);
+  }, [handlers?.onRecordingStarted]);
+  (0, import_react4.useEffect)(() => {
+    if (!handlers?.onRecordingStopped) return;
+    return ctx.onRecordingStopped(handlers.onRecordingStopped);
+  }, [handlers?.onRecordingStopped]);
+  const { sdk: _, ...publicApi } = ctx;
+  return publicApi;
+};
+
+// src/react/useParticipants.ts
+var import_react5 = require("react");
+var useParticipants = () => {
+  const { sdk } = useMeetingContext();
+  const [participants, setParticipants] = (0, import_react5.useState)(
+    () => sdk.state.getParticipants()
+  );
+  (0, import_react5.useEffect)(() => {
+    const update = () => {
+      setParticipants(sdk.state.getParticipants());
+    };
+    update();
+    const unsub = sdk.state.subscribe("participants", update);
+    return unsub;
+  }, [sdk]);
+  return participants;
+};
+
+// src/react/useRemoteMedia.ts
+var import_react6 = require("react");
+var useRemoteMedia = (participantId) => {
+  const { sdk } = useMeetingContext();
+  const videoRef = (0, import_react6.useRef)(null);
+  const audioRef = (0, import_react6.useRef)(null);
+  const [participant, setParticipant] = (0, import_react6.useState)(
+    () => sdk.state.getParticipant(participantId) || null
+  );
+  (0, import_react6.useEffect)(() => {
+    const unsub = sdk.state.subscribe(`participant:${participantId}`, () => {
+      const p = sdk.state.getParticipant(participantId);
+      setParticipant(p ? { ...p } : null);
+    });
+    return unsub;
+  }, [participantId, sdk]);
+  (0, import_react6.useEffect)(() => {
+    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
+var import_react7 = require("react");
+function useMeetingPreview(roomId, userId) {
+  const [room, setRoom] = (0, import_react7.useState)(null);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const [isConnected, setIsConnected] = (0, import_react7.useState)(false);
+  const [isLoading, setIsLoading] = (0, import_react7.useState)(true);
+  (0, import_react7.useEffect)(() => {
+    if (!roomId) {
+      setIsLoading(false);
+      return;
+    }
+    let stopped = false;
+    let timer = null;
+    const load = async () => {
+      try {
+        const response = await fetch(
+          `${SDK_CONFIG.apiBase}/rooms/${encodeURIComponent(roomId)}`
+        );
+        if (!response.ok) {
+          throw new Error(`Room lookup failed (${response.status})`);
+        }
+        const data = await response.json();
+        if (stopped) return;
+        setRoom({
+          active: true,
+          // The current REST room model intentionally does not expose a live
+          // participant count. Do not fabricate one.
+          count: 0,
+          canJoin: !data.is_private,
+          approved: false,
+          isHost: false,
+          hasMoreParticipants: false,
+          participants: [],
+          room: {
+            id: data.id,
+            name: data.name,
+            room_code: data.room_code,
+            capacity: data.capacity,
+            is_private: data.is_private
+          }
+        });
+        setError(null);
+        setIsConnected(true);
+        setIsLoading(false);
+      } catch (err) {
+        if (stopped) return;
+        setError(err?.message || "Failed to load room");
+        setIsConnected(false);
+        setIsLoading(false);
+      } finally {
+        if (!stopped) {
+          timer = setTimeout(load, 5e3);
+        }
+      }
+    };
+    void load();
+    return () => {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    };
+  }, [roomId, userId]);
+  return {
+    room,
+    isConnected,
+    isLoading,
+    error
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MeetingProvider,
+  MeetingState,
+  SFUClient,
+  VideoSDKCore,
+  useLocalParticipant,
+  useMeeting,
+  useMeetingContext,
+  useMeetingPreview,
+  useParticipants,
+  useRemoteMedia
+});
+//# sourceMappingURL=index.js.map