mediasfu-shared 1.1.0 → 1.2.0

package/dist/getParticipantMedia-CdcYqcbD.cjs

@@ -0,0 +1,3554 @@
+"use strict";
+const joinLocalRoom = require("./joinLocalRoom-BdM1msQt.cjs");
+const updateParticipantAudioDecibels = require("./updateParticipantAudioDecibels-DPmHiy3K.cjs");
+const launchBackground = ({
+  updateIsBackgroundModalVisible,
+  isBackgroundModalVisible
+}) => {
+  updateIsBackgroundModalVisible(!isBackgroundModalVisible);
+};
+const handleStartBreakout = ({
+  socket,
+  localSocket,
+  breakoutRooms,
+  newParticipantAction,
+  roomName,
+  breakOutRoomStarted,
+  breakOutRoomEnded,
+  showAlert,
+  updateBreakOutRoomStarted,
+  updateBreakOutRoomEnded,
+  onBreakoutRoomsClose,
+  meetingDisplayType,
+  updateMeetingDisplayType
+}) => {
+  const emitName = breakOutRoomStarted && !breakOutRoomEnded ? "updateBreakout" : "startBreakout";
+  const filteredBreakoutRooms = breakoutRooms.map(
+    (room) => room.map(({ name, breakRoom }) => ({ name, breakRoom }))
+  );
+  socket.emit(
+    emitName,
+    { breakoutRooms: filteredBreakoutRooms, newParticipantAction, roomName },
+    (response) => {
+      if (response.success) {
+        showAlert?.({ message: "Breakout rooms active", type: "success" });
+        updateBreakOutRoomStarted(true);
+        updateBreakOutRoomEnded(false);
+        onBreakoutRoomsClose();
+        if (meetingDisplayType !== "all") {
+          updateMeetingDisplayType("all");
+        }
+      } else {
+        showAlert?.({ message: response.reason, type: "danger" });
+      }
+    }
+  );
+  if (localSocket && localSocket.id) {
+    try {
+      localSocket.emit(
+        emitName,
+        { breakoutRooms: filteredBreakoutRooms, newParticipantAction, roomName },
+        (response) => {
+          if (response.success) {
+          }
+        }
+      );
+    } catch {
+      console.log("Error starting local breakout rooms:");
+    }
+  }
+};
+const handleStopBreakout = ({
+  socket,
+  localSocket,
+  roomName,
+  showAlert,
+  updateBreakOutRoomStarted,
+  updateBreakOutRoomEnded,
+  onBreakoutRoomsClose,
+  meetingDisplayType,
+  prevMeetingDisplayType,
+  updateMeetingDisplayType
+}) => {
+  socket.emit("stopBreakout", { roomName }, (response) => {
+    if (response.success) {
+      showAlert?.({ message: "Breakout rooms stopped", type: "success" });
+      updateBreakOutRoomStarted(false);
+      updateBreakOutRoomEnded(true);
+      onBreakoutRoomsClose();
+      if (meetingDisplayType !== prevMeetingDisplayType) {
+        updateMeetingDisplayType(prevMeetingDisplayType);
+      }
+    } else {
+      showAlert?.({ message: response.reason, type: "danger" });
+    }
+  });
+  if (localSocket && localSocket.id) {
+    try {
+      localSocket.emit("stopBreakout", { roomName }, (response) => {
+        if (response.success) {
+        }
+      });
+    } catch {
+      console.log("Error stopping local breakout rooms:");
+    }
+  }
+};
+const launchBreakoutRooms = ({
+  updateIsBreakoutRoomsModalVisible,
+  isBreakoutRoomsModalVisible
+}) => {
+  updateIsBreakoutRoomsModalVisible(!isBreakoutRoomsModalVisible);
+};
+const launchCoHost = ({ updateIsCoHostModalVisible, isCoHostModalVisible }) => {
+  updateIsCoHostModalVisible(!isCoHostModalVisible);
+};
+const modifyCoHostSettings = async ({
+  roomName,
+  // showAlert,
+  selectedParticipant,
+  coHost,
+  coHostResponsibility,
+  updateIsCoHostModalVisible,
+  updateCoHostResponsibility,
+  updateCoHost,
+  socket
+}) => {
+  let newCoHost = coHost;
+  if (coHost !== "No coHost" || selectedParticipant && selectedParticipant !== "Select a participant") {
+    if (selectedParticipant && selectedParticipant !== "Select a participant") {
+      newCoHost = selectedParticipant;
+      updateCoHost(newCoHost);
+    }
+    updateCoHostResponsibility(coHostResponsibility);
+    socket.emit("updateCoHost", {
+      roomName,
+      coHost: newCoHost,
+      coHostResponsibility
+    });
+  }
+  updateIsCoHostModalVisible(false);
+};
+const launchDisplaySettings = ({
+  updateIsDisplaySettingsModalVisible,
+  isDisplaySettingsModalVisible
+}) => {
+  updateIsDisplaySettingsModalVisible(!isDisplaySettingsModalVisible);
+};
+const modifyDisplaySettings = async ({
+  parameters
+}) => {
+  let {
+    showAlert,
+    meetingDisplayType,
+    autoWave,
+    forceFullDisplay,
+    showSubtitlesOnCards = true,
+    meetingVideoOptimized,
+    islevel,
+    recordStarted,
+    recordResumed,
+    recordStopped,
+    recordPaused,
+    recordingDisplayType,
+    recordingVideoOptimized,
+    prevForceFullDisplay,
+    prevMeetingDisplayType,
+    updateMeetingDisplayType,
+    updateAutoWave,
+    updateForceFullDisplay,
+    updateShowSubtitlesOnCards,
+    updateMeetingVideoOptimized,
+    updatePrevForceFullDisplay,
+    updatePrevMeetingDisplayType,
+    updateIsDisplaySettingsModalVisible,
+    updateFirstAll,
+    updateUpdateMainWindow,
+    breakOutRoomStarted,
+    breakOutRoomEnded,
+    onScreenChanges
+  } = parameters;
+  updateAutoWave(autoWave);
+  updateForceFullDisplay(forceFullDisplay);
+  updateShowSubtitlesOnCards?.(showSubtitlesOnCards);
+  if (islevel === "2" && (recordStarted || recordResumed) && !recordStopped && !recordPaused) {
+    if (recordingDisplayType === "video" && meetingDisplayType === "video" && meetingVideoOptimized && !recordingVideoOptimized) {
+      showAlert?.({
+        message: "Meeting display type can be either video, media, or all when recording display type is non-optimized video.",
+        type: "danger",
+        duration: 3e3
+      });
+      meetingDisplayType = recordingDisplayType;
+      updateMeetingDisplayType(meetingDisplayType);
+      meetingVideoOptimized = recordingVideoOptimized;
+      updateMeetingVideoOptimized(meetingVideoOptimized);
+      return;
+    } else if (recordingDisplayType === "media" && meetingDisplayType === "video") {
+      showAlert?.({
+        message: "Meeting display type can be either media or all when recording display type is media.",
+        type: "danger",
+        duration: 3e3
+      });
+      meetingDisplayType = recordingDisplayType;
+      updateMeetingDisplayType(meetingDisplayType);
+      return;
+    } else if (recordingDisplayType === "all" && (meetingDisplayType === "video" || meetingDisplayType === "media")) {
+      showAlert?.({
+        message: "Meeting display type can be only all when recording display type is all.",
+        type: "danger",
+        duration: 3e3
+      });
+      meetingDisplayType = recordingDisplayType;
+      updateMeetingDisplayType(meetingDisplayType);
+      return;
+    }
+  }
+  updateMeetingDisplayType(meetingDisplayType);
+  updateMeetingVideoOptimized(meetingVideoOptimized);
+  updateIsDisplaySettingsModalVisible(false);
+  if (prevMeetingDisplayType !== meetingDisplayType || prevForceFullDisplay !== forceFullDisplay) {
+    if (breakOutRoomStarted && !breakOutRoomEnded && meetingDisplayType !== "all") {
+      showAlert?.({
+        message: "Breakout room is active. Display type can only be all.",
+        type: "danger"
+      });
+      meetingDisplayType = prevMeetingDisplayType;
+      updateMeetingDisplayType(prevMeetingDisplayType);
+      return;
+    }
+    updateFirstAll(meetingDisplayType !== "all" ? true : false);
+    updateUpdateMainWindow(true);
+    await onScreenChanges({
+      changed: true,
+      parameters: { ...parameters, meetingDisplayType, forceFullDisplay }
+    });
+    updatePrevForceFullDisplay(forceFullDisplay);
+    updatePrevMeetingDisplayType(meetingDisplayType);
+  }
+};
+const confirmExit = async ({
+  socket,
+  localSocket,
+  member,
+  roomName,
+  ban = false,
+  endRoomOnHostExit = true
+}) => {
+  socket.emit("disconnectUser", {
+    member,
+    roomName,
+    ban,
+    endRoomOnHostExit
+  });
+  if (localSocket && localSocket.id) {
+    localSocket.emit("disconnectUser", {
+      member,
+      roomName,
+      ban,
+      endRoomOnHostExit
+    });
+  }
+};
+const launchConfirmExit = ({
+  updateIsConfirmExitModalVisible,
+  isConfirmExitModalVisible
+}) => {
+  updateIsConfirmExitModalVisible(!isConfirmExitModalVisible);
+};
+const launchMediaSettings = async ({
+  updateIsMediaSettingsModalVisible,
+  isMediaSettingsModalVisible,
+  mediaDevices,
+  audioInputs,
+  videoInputs,
+  updateAudioInputs,
+  updateVideoInputs
+}) => {
+  if (!isMediaSettingsModalVisible) {
+    try {
+      const devices = await mediaDevices.enumerateDevices();
+      videoInputs = devices.filter((device) => device.kind === "videoinput");
+      audioInputs = devices.filter((device) => device.kind === "audioinput");
+      updateVideoInputs(videoInputs);
+      updateAudioInputs(audioInputs);
+    } catch (error) {
+      console.log("Error getting media devices", error);
+    }
+  }
+  updateIsMediaSettingsModalVisible(!isMediaSettingsModalVisible);
+};
+const launchMenuModal = ({
+  updateIsMenuModalVisible,
+  isMenuModalVisible
+}) => {
+  updateIsMenuModalVisible(!isMenuModalVisible);
+};
+const launchMessages = ({ updateIsMessagesModalVisible, isMessagesModalVisible }) => {
+  updateIsMessagesModalVisible(!isMessagesModalVisible);
+};
+const sendMessage = async ({
+  message,
+  receivers,
+  group,
+  messagesLength,
+  member,
+  sender,
+  islevel,
+  showAlert,
+  coHostResponsibility,
+  coHost,
+  roomName,
+  socket,
+  chatSetting
+}) => {
+  let chatValue = false;
+  const normalizedReceivers = (receivers ?? []).filter(
+    (receiver) => typeof receiver === "string" && receiver.trim().length > 0
+  );
+  if (messagesLength > 100 && roomName.startsWith("d") || messagesLength > 500 && roomName.startsWith("s") || messagesLength > 1e5 && roomName.startsWith("p")) {
+    showAlert?.({
+      message: "You have reached the maximum number of messages allowed.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (!message || message === "") {
+    showAlert?.({
+      message: "Message is not valid.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (normalizedReceivers.length < 1 && group === false && islevel === "2") {
+    showAlert?.({
+      message: "Please select a message to reply to",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  const messageObject = {
+    sender: sender ? sender : member,
+    receivers: normalizedReceivers,
+    message,
+    timestamp: (/* @__PURE__ */ new Date()).toLocaleTimeString(),
+    group: group !== void 0 && group !== null ? group : false
+  };
+  try {
+    chatValue = coHostResponsibility.find((item) => item.name === "chat")?.value ?? false;
+  } catch (error) {
+    console.error(error);
+  }
+  if (islevel === "2" || coHost === member && chatValue === true) ;
+  else {
+    if (!chatSetting) {
+      showAlert?.({
+        message: "You are not allowed to send a message in this event room",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+  }
+  socket.emit("sendMessage", {
+    messageObject,
+    roomName
+  });
+};
+const launchParticipants = ({ updateIsParticipantsModalVisible, isParticipantsModalVisible }) => {
+  updateIsParticipantsModalVisible(!isParticipantsModalVisible);
+};
+const messageParticipants = ({
+  coHostResponsibility = [],
+  participant,
+  member,
+  islevel,
+  showAlert,
+  coHost,
+  updateIsMessagesModalVisible,
+  updateDirectMessageDetails,
+  updateStartDirectMessage
+}) => {
+  let chatValue = false;
+  try {
+    chatValue = coHostResponsibility.find((item) => item.name === "chat")?.value ?? false;
+  } catch (error) {
+    console.error(error);
+  }
+  if (islevel === "2" || coHost === member && chatValue === true) {
+    if (participant.islevel !== "2") {
+      updateDirectMessageDetails(participant);
+      updateStartDirectMessage(true);
+      updateIsMessagesModalVisible(true);
+    }
+  } else {
+    showAlert?.({
+      message: "You are not allowed to send this message",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+};
+const muteParticipants = async ({
+  socket,
+  coHostResponsibility = [],
+  participant,
+  member,
+  islevel,
+  showAlert,
+  coHost,
+  roomName
+}) => {
+  let mediaValue = false;
+  try {
+    mediaValue = coHostResponsibility.find((item) => item.name === "media")?.value ?? false;
+  } catch (error) {
+    console.error(error);
+  }
+  if (islevel === "2" || coHost === member && mediaValue) {
+    if (!participant.muted && participant.islevel !== "2") {
+      const participantId = participant.id;
+      socket.emit("controlMedia", {
+        participantId,
+        participantName: participant.name,
+        type: "all",
+        roomName
+      });
+    }
+  } else {
+    showAlert?.({
+      message: "You are not allowed to mute other participants",
+      type: "danger",
+      duration: 3e3
+    });
+  }
+};
+const removeParticipants = async ({
+  coHostResponsibility,
+  participant,
+  member,
+  islevel,
+  showAlert,
+  coHost,
+  participants,
+  socket,
+  roomName,
+  updateParticipants
+}) => {
+  let participantsValue = false;
+  try {
+    participantsValue = coHostResponsibility.find((item) => item.name === "participants")?.value ?? false;
+  } catch {
+    participantsValue = false;
+  }
+  if (islevel === "2" || coHost === member && participantsValue === true) {
+    if (participant.islevel !== "2") {
+      const participantId = participant.id;
+      socket.emit("disconnectUserInitiate", {
+        member: participant.name,
+        roomName,
+        id: participantId
+      });
+      const index = participants.findIndex((obj) => obj.name === participant.name);
+      if (index !== -1) {
+        participants.splice(index, 1);
+      }
+      updateParticipants(participants);
+    }
+  } else {
+    showAlert?.({
+      message: "You are not allowed to remove other participants",
+      type: "danger",
+      duration: 3e3
+    });
+  }
+};
+const handleCreatePoll = async ({
+  poll,
+  socket,
+  roomName,
+  showAlert,
+  updateIsPollModalVisible
+}) => {
+  try {
+    socket.emit(
+      "createPoll",
+      { roomName, poll },
+      (response) => {
+        if (response.success) {
+          showAlert?.({ message: "Poll created successfully", type: "success" });
+          updateIsPollModalVisible(false);
+        } else {
+          showAlert?.({ message: response.reason || "Failed to create poll", type: "danger" });
+        }
+      }
+    );
+  } catch (error) {
+    console.error("Error creating poll:", error);
+  }
+};
+const handleEndPoll = async ({
+  pollId,
+  socket,
+  showAlert,
+  roomName,
+  updateIsPollModalVisible
+}) => {
+  try {
+    socket.emit(
+      "endPoll",
+      { roomName, poll_id: pollId },
+      (response) => {
+        if (response.success) {
+          showAlert?.({
+            message: "Poll ended successfully",
+            type: "success"
+          });
+          updateIsPollModalVisible(false);
+        } else {
+          showAlert?.({ message: response.reason || "Failed to end poll", type: "danger" });
+        }
+      }
+    );
+  } catch (error) {
+    console.error("Error ending poll:", error);
+  }
+};
+const handleVotePoll = async ({
+  pollId,
+  optionIndex,
+  socket,
+  showAlert,
+  member,
+  roomName,
+  updateIsPollModalVisible
+}) => {
+  try {
+    socket.emit(
+      "votePoll",
+      {
+        roomName,
+        poll_id: pollId,
+        member,
+        choice: optionIndex
+      },
+      (response) => {
+        if (response.success) {
+          showAlert?.({
+            message: "Vote submitted successfully",
+            type: "success"
+          });
+          updateIsPollModalVisible(false);
+        } else {
+          showAlert?.({ message: response.reason || "Failed to submit vote", type: "danger" });
+        }
+      }
+    );
+  } catch (error) {
+    console.error("Error submitting vote:", error);
+  }
+};
+const launchPoll = ({ updateIsPollModalVisible, isPollModalVisible }) => {
+  updateIsPollModalVisible(!isPollModalVisible);
+};
+const checkPauseState = async ({
+  recordingMediaOptions,
+  recordingVideoPausesLimit,
+  recordingAudioPausesLimit,
+  pauseRecordCount,
+  showAlert
+}) => {
+  const refLimit = recordingMediaOptions === "video" ? recordingVideoPausesLimit : recordingAudioPausesLimit;
+  if (pauseRecordCount < refLimit) {
+    return true;
+  }
+  showAlert?.({
+    message: "You have reached the limit of pauses - you can choose to stop recording.",
+    type: "danger",
+    duration: 3e3
+  });
+  return false;
+};
+const checkResumeState = async ({
+  recordingMediaOptions,
+  recordingVideoPausesLimit,
+  recordingAudioPausesLimit,
+  pauseRecordCount
+}) => {
+  const refLimit = recordingMediaOptions === "video" ? recordingVideoPausesLimit : recordingAudioPausesLimit;
+  return pauseRecordCount <= refLimit;
+};
+const ALERT_DURATION = 6e3;
+const FULL_PARTICIPANT_RECORDING_ALERT_MESSAGE = "You are not allowed to record videos of all participants while the meeting display is set to All. Switch the meeting display to Media and try again.";
+const confirmRecording = async ({
+  parameters
+}) => {
+  parameters = parameters.getUpdatedAllParams();
+  let {
+    showAlert,
+    recordingMediaOptions,
+    recordingAudioOptions,
+    recordingVideoOptions,
+    recordingVideoType,
+    recordingDisplayType,
+    recordingNameTags,
+    recordingBackgroundColor,
+    recordingNameTagsColor,
+    recordingOrientationVideo,
+    recordingAddHLS,
+    recordingAddText,
+    recordingCustomText,
+    recordingCustomTextPosition,
+    recordingCustomTextColor,
+    meetingDisplayType,
+    recordingVideoParticipantsFullRoomSupport,
+    recordingAllParticipantsSupport,
+    recordingVideoParticipantsSupport,
+    recordingSupportForOtherOrientation,
+    recordingPreferredOrientation,
+    recordingMultiFormatsSupport,
+    recordingVideoOptimized,
+    recordingAllParticipantsFullRoomSupport,
+    meetingVideoOptimized,
+    eventType,
+    breakOutRoomStarted,
+    breakOutRoomEnded,
+    updateRecordingDisplayType,
+    updateRecordingVideoOptimized,
+    updateUserRecordingParams,
+    updateConfirmedToRecord
+  } = parameters;
+  if (!recordingVideoParticipantsFullRoomSupport && recordingVideoOptions === "all" && recordingMediaOptions === "video") {
+    if (meetingDisplayType === "all" && !(breakOutRoomStarted && !breakOutRoomEnded)) {
+      showAlert?.({
+        message: FULL_PARTICIPANT_RECORDING_ALERT_MESSAGE,
+        type: "danger",
+        duration: ALERT_DURATION
+      });
+      return;
+    }
+  }
+  if (!recordingAllParticipantsSupport && recordingVideoOptions === "all") {
+    showAlert?.({
+      message: "You are only allowed to record yourself.",
+      type: "danger",
+      duration: ALERT_DURATION
+    });
+    return;
+  }
+  if (!recordingVideoParticipantsSupport && recordingDisplayType === "video") {
+    showAlert?.({
+      message: "You are not allowed to record other video participants.",
+      type: "danger",
+      duration: ALERT_DURATION
+    });
+    return;
+  }
+  if (!recordingSupportForOtherOrientation && recordingOrientationVideo === "all") {
+    showAlert?.({
+      message: "You are not allowed to record all orientations.",
+      type: "danger",
+      duration: ALERT_DURATION
+    });
+    return;
+  }
+  if (recordingPreferredOrientation === "landscape" && recordingOrientationVideo === "portrait" || recordingPreferredOrientation === "portrait" && recordingOrientationVideo === "landscape") {
+    if (!recordingSupportForOtherOrientation) {
+      showAlert?.({
+        message: "You are not allowed to record this orientation.",
+        type: "danger",
+        duration: ALERT_DURATION
+      });
+      return;
+    }
+  }
+  if (!recordingMultiFormatsSupport && recordingVideoType === "all") {
+    showAlert?.({
+      message: "You are not allowed to record all formats.",
+      type: "danger",
+      duration: ALERT_DURATION
+    });
+    return;
+  }
+  if (eventType !== "broadcast") {
+    if (recordingMediaOptions === "video") {
+      if (meetingDisplayType === "media" && recordingDisplayType === "all") {
+        showAlert?.({
+          message: "Recording display type can be either video, video optimized, or media when meeting display type is media.",
+          type: "danger",
+          duration: ALERT_DURATION
+        });
+        updateRecordingDisplayType(meetingDisplayType);
+        return;
+      }
+      if (meetingDisplayType === "video") {
+        if (recordingDisplayType === "all" || recordingDisplayType === "media") {
+          showAlert?.({
+            message: "Recording display type can be either video or video optimized when meeting display type is video.",
+            type: "danger",
+            duration: ALERT_DURATION
+          });
+          updateRecordingDisplayType(meetingDisplayType);
+          return;
+        }
+        if (meetingVideoOptimized && !recordingVideoOptimized) {
+          showAlert?.({
+            message: "Recording display type can only be video optimized when meeting display type is video optimized.",
+            type: "danger",
+            duration: ALERT_DURATION
+          });
+          updateRecordingVideoOptimized(meetingVideoOptimized);
+          return;
+        }
+      }
+    } else {
+      updateRecordingDisplayType("media");
+      updateRecordingVideoOptimized(false);
+    }
+  }
+  if (recordingDisplayType === "all" && !recordingAllParticipantsFullRoomSupport) {
+    showAlert?.({
+      message: "You can only record all participants with media.",
+      type: "danger",
+      duration: ALERT_DURATION
+    });
+    return;
+  }
+  const mainSpecs = {
+    mediaOptions: recordingMediaOptions,
+    audioOptions: recordingAudioOptions,
+    videoOptions: recordingVideoOptions,
+    videoType: recordingVideoType,
+    videoOptimized: recordingVideoOptimized,
+    recordingDisplayType,
+    addHLS: recordingAddHLS
+  };
+  const dispSpecs = {
+    nameTags: recordingNameTags,
+    backgroundColor: recordingBackgroundColor,
+    nameTagsColor: recordingNameTagsColor,
+    orientationVideo: recordingOrientationVideo
+  };
+  const textSpecs = {
+    addText: recordingAddText,
+    customText: recordingCustomText,
+    customTextPosition: recordingCustomTextPosition,
+    customTextColor: recordingCustomTextColor
+  };
+  const userRecordingParams = { mainSpecs, dispSpecs, textSpecs };
+  updateUserRecordingParams(userRecordingParams);
+  updateConfirmedToRecord(true);
+};
+const launchRecording = ({
+  updateIsRecordingModalVisible,
+  isRecordingModalVisible,
+  showAlert,
+  stopLaunchRecord,
+  canLaunchRecord,
+  recordingAudioSupport,
+  recordingVideoSupport,
+  updateCanRecord,
+  updateClearedToRecord,
+  recordStarted,
+  recordPaused,
+  localUIMode
+}) => {
+  if (!isRecordingModalVisible && stopLaunchRecord && !localUIMode) {
+    showAlert?.({
+      message: "Recording has already ended or you are not allowed to record",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (!isRecordingModalVisible && canLaunchRecord && !localUIMode) {
+    if (!recordingAudioSupport && !recordingVideoSupport) {
+      showAlert?.({
+        message: "You are not allowed to record",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+    updateClearedToRecord(false);
+    updateCanRecord(false);
+  }
+  if (!isRecordingModalVisible && recordStarted && !recordPaused) {
+    showAlert?.({
+      message: "You can only re-configure recording after pausing it",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (!isRecordingModalVisible && !recordingAudioSupport && !recordingVideoSupport && !localUIMode) {
+    showAlert?.({
+      message: "You are not allowed to record",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  updateIsRecordingModalVisible(!isRecordingModalVisible);
+};
+const recordPauseTimer = ({
+  stop = false,
+  isTimerRunning,
+  canPauseResume,
+  showAlert
+}) => {
+  if (isTimerRunning && canPauseResume) {
+    return true;
+  }
+  const message = stop ? "Can only stop after 15 seconds of starting or pausing or resuming recording" : "Can only pause or resume after 15 seconds of starting or pausing or resuming recording";
+  showAlert?.({
+    message,
+    type: "danger"
+  });
+  return false;
+};
+const recordUpdateTimer = ({
+  recordElapsedTime,
+  recordStartTime,
+  updateRecordElapsedTime,
+  updateRecordingProgressTime
+}) => {
+  const padNumber = (value) => value.toString().padStart(2, "0");
+  const currentTime = (/* @__PURE__ */ new Date()).getTime();
+  let elapsedSeconds = recordElapsedTime;
+  elapsedSeconds = Math.floor((currentTime - recordStartTime) / 1e3);
+  updateRecordElapsedTime(elapsedSeconds);
+  const hours = Math.floor(elapsedSeconds / 3600);
+  const minutes = Math.floor(elapsedSeconds % 3600 / 60);
+  const seconds = elapsedSeconds % 60;
+  const formattedTime = `${padNumber(hours)}:${padNumber(minutes)}:${padNumber(seconds)}`;
+  updateRecordingProgressTime(formattedTime);
+};
+const recordResumeTimer = async ({ parameters }) => {
+  const { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+  let {
+    isTimerRunning,
+    canPauseResume,
+    recordElapsedTime,
+    recordStartTime,
+    recordTimerInterval,
+    showAlert,
+    updateRecordStartTime,
+    updateRecordTimerInterval,
+    updateIsTimerRunning,
+    updateCanPauseResume
+  } = parameters;
+  if (!isTimerRunning && canPauseResume) {
+    recordStartTime = (/* @__PURE__ */ new Date()).getTime() - recordElapsedTime * 1e3;
+    updateRecordStartTime(recordStartTime);
+    recordTimerInterval = setInterval(() => {
+      recordUpdateTimer({
+        recordElapsedTime,
+        recordStartTime,
+        updateRecordElapsedTime: parameters.updateRecordElapsedTime,
+        updateRecordingProgressTime: parameters.updateRecordingProgressTime
+      });
+      parameters = getUpdatedAllParams();
+      if (parameters.recordPaused || parameters.recordStopped || parameters.roomName === "" || parameters.roomName === null) {
+        clearInterval(recordTimerInterval);
+        updateRecordTimerInterval(null);
+        isTimerRunning = false;
+        updateIsTimerRunning(isTimerRunning);
+        canPauseResume = false;
+        updateCanPauseResume(canPauseResume);
+      }
+    }, 1e3);
+    updateRecordTimerInterval(recordTimerInterval);
+    isTimerRunning = true;
+    updateIsTimerRunning(isTimerRunning);
+    canPauseResume = false;
+    updateCanPauseResume(canPauseResume);
+    return true;
+  }
+  showAlert?.({
+    type: "danger",
+    message: "Can only pause or resume after 15 seconds of starting or pausing or resuming recording"
+  });
+  return false;
+};
+const recordStartTimer = async ({ parameters }) => {
+  const { getUpdatedAllParams } = parameters;
+  parameters = getUpdatedAllParams();
+  let {
+    recordStartTime,
+    recordTimerInterval,
+    isTimerRunning,
+    canPauseResume,
+    recordChangeSeconds,
+    updateRecordStartTime,
+    updateRecordTimerInterval,
+    updateIsTimerRunning,
+    updateCanPauseResume
+  } = parameters;
+  const enablePauseResume = () => {
+    canPauseResume = true;
+    updateCanPauseResume(canPauseResume);
+  };
+  if (!isTimerRunning) {
+    recordStartTime = (/* @__PURE__ */ new Date()).getTime();
+    updateRecordStartTime(recordStartTime);
+    recordTimerInterval = setInterval(() => {
+      recordUpdateTimer({
+        recordElapsedTime: parameters.recordElapsedTime,
+        recordStartTime,
+        updateRecordElapsedTime: parameters.updateRecordElapsedTime,
+        updateRecordingProgressTime: parameters.updateRecordingProgressTime
+      });
+      parameters = getUpdatedAllParams();
+      if (parameters.recordPaused || parameters.recordStopped || parameters.roomName === "" || parameters.roomName === null) {
+        clearInterval(recordTimerInterval);
+        updateRecordTimerInterval(null);
+        isTimerRunning = false;
+        updateIsTimerRunning(isTimerRunning);
+        canPauseResume = false;
+        updateCanPauseResume(canPauseResume);
+      }
+    }, 1e3);
+    updateRecordTimerInterval(recordTimerInterval);
+    isTimerRunning = true;
+    updateIsTimerRunning(isTimerRunning);
+    canPauseResume = false;
+    updateCanPauseResume(canPauseResume);
+    setTimeout(enablePauseResume, recordChangeSeconds);
+  }
+};
+const startRecording = async ({
+  parameters
+}) => {
+  parameters = parameters.getUpdatedAllParams();
+  let {
+    roomName,
+    userRecordingParams,
+    socket,
+    localSocket,
+    updateIsRecordingModalVisible,
+    confirmedToRecord,
+    showAlert,
+    recordingMediaOptions,
+    videoAlreadyOn,
+    audioAlreadyOn,
+    recordStarted,
+    recordPaused,
+    recordResumed,
+    recordStopped,
+    startReport,
+    endReport,
+    canRecord,
+    updateClearedToRecord,
+    updateRecordStarted,
+    updateRecordPaused,
+    updateRecordResumed,
+    updateStartReport,
+    updateEndReport,
+    updateCanRecord,
+    whiteboardStarted,
+    whiteboardEnded,
+    rePort,
+    captureCanvasStream
+  } = parameters;
+  if (!confirmedToRecord) {
+    showAlert?.({
+      message: "You must click confirm before you can start recording",
+      type: "danger"
+    });
+    return false;
+  }
+  if (recordingMediaOptions === "video" && !videoAlreadyOn) {
+    showAlert?.({
+      message: "You must turn on your video before you can start recording",
+      type: "danger"
+    });
+    return false;
+  }
+  if (recordingMediaOptions === "audio" && !audioAlreadyOn) {
+    showAlert?.({
+      message: "You must turn on your audio before you can start recording",
+      type: "danger"
+    });
+    return false;
+  }
+  updateClearedToRecord(true);
+  let action = "startRecord";
+  if (recordStarted && recordPaused && !recordResumed && !recordStopped) {
+    action = "resumeRecord";
+  }
+  let recAttempt = false;
+  const socketRef = localSocket && localSocket.connected ? localSocket : socket;
+  await new Promise((resolve) => {
+    socketRef.emit(
+      action,
+      { roomName, userRecordingParams },
+      async ({ success, reason }) => {
+        if (success) {
+          recordStarted = true;
+          startReport = true;
+          endReport = false;
+          recordPaused = false;
+          recAttempt = true;
+          updateRecordStarted(recordStarted);
+          updateStartReport(startReport);
+          updateEndReport(endReport);
+          updateRecordPaused(recordPaused);
+          if (action === "startRecord") {
+            await rePort({ parameters: parameters.getUpdatedAllParams() });
+            await recordStartTimer({ parameters });
+          } else {
+            updateRecordResumed(true);
+            await rePort({ restart: true, parameters: parameters.getUpdatedAllParams() });
+            await recordResumeTimer({ parameters });
+          }
+        } else {
+          showAlert?.({
+            message: `Recording could not start - ${reason}`,
+            type: "danger"
+          });
+          canRecord = true;
+          startReport = false;
+          endReport = true;
+          recAttempt = false;
+          updateCanRecord(canRecord);
+          updateStartReport(startReport);
+          updateEndReport(endReport);
+        }
+        resolve();
+      }
+    );
+  });
+  try {
+    if (recAttempt && whiteboardStarted && !whiteboardEnded && recordingMediaOptions === "video") {
+      await captureCanvasStream({ parameters: parameters.getUpdatedAllParams() });
+    }
+  } catch (error) {
+    console.error("Error capturing canvas stream:", error);
+  }
+  updateIsRecordingModalVisible(false);
+  return recAttempt;
+};
+const stopRecording = async ({ parameters }) => {
+  let {
+    roomName,
+    socket,
+    localSocket,
+    showAlert,
+    startReport,
+    endReport,
+    recordStarted,
+    recordPaused,
+    recordStopped,
+    updateRecordPaused,
+    updateRecordStopped,
+    updateStartReport,
+    updateEndReport,
+    updateShowRecordButtons,
+    whiteboardStarted,
+    whiteboardEnded,
+    recordingMediaOptions,
+    captureCanvasStream
+  } = parameters;
+  let recAttempt = false;
+  if (recordStarted && !recordStopped) {
+    const stop = recordPauseTimer({
+      stop: true,
+      isTimerRunning: parameters.isTimerRunning,
+      canPauseResume: parameters.canPauseResume,
+      showAlert: parameters.showAlert
+    });
+    if (stop) {
+      const action = "stopRecord";
+      const socketRef = localSocket && localSocket.connected ? localSocket : socket;
+      await new Promise((resolve) => {
+        socketRef.emit(
+          action,
+          { roomName },
+          ({ success, reason, recordState }) => {
+            if (success) {
+              startReport = false;
+              endReport = true;
+              recordPaused = false;
+              recordStopped = true;
+              recAttempt = true;
+              updateStartReport(startReport);
+              updateEndReport(endReport);
+              updateRecordPaused(recordPaused);
+              updateRecordStopped(recordStopped);
+              showAlert?.({ message: "Recording Stopped", type: "success" });
+              updateShowRecordButtons(false);
+            } else {
+              const reasonMessage = `Recording Stop Failed: ${reason}; the recording is currently ${recordState}`;
+              showAlert?.({ message: reasonMessage, type: "danger" });
+              recAttempt = false;
+            }
+            resolve();
+          }
+        );
+      });
+      try {
+        if (recAttempt && whiteboardStarted && !whiteboardEnded && recordingMediaOptions === "video") {
+          captureCanvasStream({ parameters: parameters.getUpdatedAllParams(), start: false });
+        }
+      } catch (error) {
+        console.error("Error capturing canvas stream:", error);
+      }
+    } else {
+      return;
+    }
+  } else {
+    showAlert?.({
+      message: "Recording is not started yet or already stopped",
+      type: "danger"
+    });
+  }
+};
+const updateRecording = async ({ parameters }) => {
+  let {
+    roomName,
+    userRecordingParams,
+    socket,
+    localSocket,
+    updateIsRecordingModalVisible,
+    confirmedToRecord,
+    showAlert,
+    recordingMediaOptions,
+    videoAlreadyOn,
+    audioAlreadyOn,
+    recordStarted,
+    recordPaused,
+    recordResumed,
+    recordStopped,
+    recordChangeSeconds,
+    pauseRecordCount,
+    startReport,
+    endReport,
+    canRecord,
+    canPauseResume,
+    updateCanPauseResume,
+    updatePauseRecordCount,
+    updateClearedToRecord,
+    updateRecordPaused,
+    updateRecordResumed,
+    updateStartReport,
+    updateEndReport,
+    updateCanRecord,
+    rePort
+  } = parameters;
+  if (recordStopped) {
+    showAlert?.({
+      message: "Recording has already stopped",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (recordingMediaOptions === "video" && !videoAlreadyOn) {
+    showAlert?.({
+      message: "You must turn on your video before you can start recording",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (recordingMediaOptions === "audio" && !audioAlreadyOn) {
+    showAlert?.({
+      message: "You must turn on your audio before you can start recording",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  const socketRef = localSocket && localSocket.connected ? localSocket : socket;
+  if (recordStarted && !recordPaused && !recordStopped) {
+    const proceed = await checkPauseState({
+      recordingMediaOptions,
+      recordingVideoPausesLimit: parameters.recordingVideoPausesLimit,
+      recordingAudioPausesLimit: parameters.recordingAudioPausesLimit,
+      pauseRecordCount,
+      showAlert
+    });
+    if (!proceed) return;
+    const record = recordPauseTimer({
+      stop: false,
+      isTimerRunning: parameters.isTimerRunning,
+      canPauseResume: parameters.canPauseResume,
+      showAlert
+    });
+    if (record) {
+      const action = "pauseRecord";
+      await new Promise((resolve) => {
+        socketRef.emit(
+          action,
+          { roomName },
+          async ({ success, reason, recordState, pauseCount }) => {
+            pauseRecordCount = pauseCount;
+            updatePauseRecordCount(pauseRecordCount);
+            if (success) {
+              startReport = false;
+              endReport = true;
+              recordPaused = true;
+              updateStartReport(startReport);
+              updateEndReport(endReport);
+              updateRecordPaused(recordPaused);
+              showAlert?.({
+                message: "Recording paused",
+                type: "success",
+                duration: 3e3
+              });
+              updateIsRecordingModalVisible(false);
+              setTimeout(() => {
+                canPauseResume = true;
+                updateCanPauseResume(canPauseResume);
+              }, recordChangeSeconds);
+            } else {
+              showAlert?.({
+                message: `Recording Pause Failed: ${reason}; the current state is: ${recordState}`,
+                type: "danger",
+                duration: 3e3
+              });
+            }
+            resolve();
+          }
+        );
+      });
+    }
+  } else if (recordStarted && recordPaused && !recordStopped) {
+    if (!confirmedToRecord) {
+      showAlert?.({
+        message: "You must click confirm before you can start recording",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+    const proceed = await checkResumeState({
+      recordingMediaOptions,
+      recordingVideoPausesLimit: parameters.recordingVideoPausesLimit,
+      recordingAudioPausesLimit: parameters.recordingAudioPausesLimit,
+      pauseRecordCount
+    });
+    if (!proceed) return;
+    const resume = await recordResumeTimer({ parameters });
+    if (resume) {
+      updateClearedToRecord(true);
+      const action = "resumeRecord";
+      await new Promise((resolve) => {
+        socketRef.emit(
+          action,
+          { roomName, userRecordingParams },
+          async ({ success, reason }) => {
+            if (success) {
+              recordResumed = true;
+              recordPaused = false;
+              updateRecordPaused(recordPaused);
+              updateRecordResumed(recordResumed);
+              await rePort({ restart: true, parameters: parameters.getUpdatedAllParams() });
+            } else {
+              showAlert?.({
+                message: `Recording could not resume - ${reason}`,
+                type: "danger",
+                duration: 3e3
+              });
+            }
+            canRecord = true;
+            startReport = false;
+            endReport = true;
+            updateCanRecord(canRecord);
+            updateStartReport(startReport);
+            updateEndReport(endReport);
+            resolve();
+          }
+        );
+      });
+      updateIsRecordingModalVisible(false);
+      setTimeout(() => {
+        updateCanPauseResume(true);
+      }, recordChangeSeconds);
+    }
+  }
+};
+const launchRequests = ({ updateIsRequestsModalVisible, isRequestsModalVisible }) => {
+  updateIsRequestsModalVisible(!isRequestsModalVisible);
+};
+const respondToRequests = async ({
+  socket,
+  request,
+  updateRequestList,
+  requestList = [],
+  action,
+  roomName
+}) => {
+  if (!request || typeof request !== "object") {
+    return;
+  }
+  if (!updateRequestList) {
+    console.warn("[respondToRequests] Missing updateRequestList handler; aborting emit.");
+    return;
+  }
+  const currentList = Array.isArray(requestList) ? requestList : [];
+  const requestIdRaw = request.id;
+  const requestIcon = request.icon;
+  const requestName = request.name;
+  if (requestIdRaw === void 0 || requestIcon === void 0 || requestName === void 0) {
+    console.warn("[respondToRequests] Request payload is missing required fields; aborting emit.", request);
+    return;
+  }
+  const requestId = String(requestIdRaw);
+  if (!requestId || !requestIcon || !requestName) {
+    console.warn("[respondToRequests] Request payload contains empty fields; aborting emit.", request);
+    return;
+  }
+  const newRequestList = currentList.filter(
+    (request_) => !(request_ && request_.id === requestId && request_.icon === requestIcon && request_.name === requestName)
+  );
+  updateRequestList(newRequestList);
+  const requestResponse = {
+    id: requestId,
+    name: requestName,
+    type: requestIcon,
+    action
+  };
+  const socketReady = socket && typeof socket.emit === "function";
+  if (!socketReady) {
+    console.warn("[respondToRequests] Socket is not ready; skipping emit.");
+    return;
+  }
+  socket.emit("updateUserofRequestStatus", { requestResponse, roomName });
+};
+const launchSettings = ({ updateIsSettingsModalVisible, isSettingsModalVisible }) => {
+  updateIsSettingsModalVisible(!isSettingsModalVisible);
+};
+const switchAudio = async ({
+  audioPreference,
+  parameters
+}) => {
+  let {
+    defAudioID,
+    userDefaultAudioInputDevice,
+    prevAudioInputDevice,
+    updateUserDefaultAudioInputDevice,
+    updatePrevAudioInputDevice,
+    //mediasfu functions
+    switchUserAudio
+  } = parameters;
+  if (audioPreference !== defAudioID) {
+    prevAudioInputDevice = userDefaultAudioInputDevice;
+    updatePrevAudioInputDevice(prevAudioInputDevice);
+    userDefaultAudioInputDevice = audioPreference;
+    updateUserDefaultAudioInputDevice(userDefaultAudioInputDevice);
+    if (defAudioID) {
+      await switchUserAudio({ audioPreference, parameters });
+    }
+  }
+};
+const switchVideo = async ({
+  videoPreference,
+  parameters
+}) => {
+  let {
+    recordStarted,
+    recordResumed,
+    recordStopped,
+    recordPaused,
+    recordingMediaOptions,
+    videoAlreadyOn,
+    userDefaultVideoInputDevice,
+    defVideoID,
+    allowed,
+    updateDefVideoID,
+    updatePrevVideoInputDevice,
+    updateUserDefaultVideoInputDevice,
+    updateIsMediaSettingsModalVisible,
+    //mediasfu functions
+    showAlert,
+    switchUserVideo
+  } = parameters;
+  let checkoff = false;
+  if ((recordStarted || recordResumed) && !recordStopped && !recordPaused) {
+    if (recordingMediaOptions === "video") {
+      checkoff = true;
+    }
+  }
+  if (!allowed) {
+    showAlert?.({
+      message: "Allow access to your camera by starting it for the first time.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (checkoff) {
+    if (videoAlreadyOn) {
+      showAlert?.({
+        message: "Please turn off your video before switching.",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+  } else {
+    if (!videoAlreadyOn) {
+      showAlert?.({
+        message: "Please turn on your video before switching.",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+  }
+  if (!defVideoID) {
+    defVideoID = userDefaultVideoInputDevice ?? "default";
+    updateDefVideoID(defVideoID);
+  }
+  if (videoPreference !== defVideoID) {
+    const prevVideoInputDevice = userDefaultVideoInputDevice;
+    updatePrevVideoInputDevice(prevVideoInputDevice);
+    userDefaultVideoInputDevice = videoPreference;
+    updateUserDefaultVideoInputDevice(userDefaultVideoInputDevice);
+    if (defVideoID) {
+      updateIsMediaSettingsModalVisible(false);
+      await switchUserVideo({ videoPreference, checkoff, parameters });
+    }
+  }
+};
+const switchVideoAlt = async ({
+  parameters
+}) => {
+  let {
+    recordStarted,
+    recordResumed,
+    recordStopped,
+    recordPaused,
+    recordingMediaOptions,
+    videoAlreadyOn,
+    currentFacingMode,
+    prevFacingMode,
+    allowed,
+    audioOnlyRoom,
+    updateCurrentFacingMode,
+    updateIsMediaSettingsModalVisible,
+    updatePrevFacingMode,
+    showAlert,
+    //media functions
+    switchUserVideoAlt
+  } = parameters;
+  if (audioOnlyRoom) {
+    showAlert?.({
+      message: "You cannot turn on your camera in an audio-only event.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  let checkoff = false;
+  if ((recordStarted || recordResumed) && !recordStopped && !recordPaused && recordingMediaOptions === "video") {
+    checkoff = true;
+  }
+  if (!allowed) {
+    showAlert?.({
+      message: "Allow access to your camera by starting it for the first time.",
+      type: "danger",
+      duration: 3e3
+    });
+    return;
+  }
+  if (checkoff) {
+    if (videoAlreadyOn) {
+      showAlert?.({
+        message: "Please turn off your video before switching.",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+  } else {
+    if (!videoAlreadyOn) {
+      showAlert?.({
+        message: "Please turn on your video before switching.",
+        type: "danger",
+        duration: 3e3
+      });
+      return;
+    }
+  }
+  prevFacingMode = currentFacingMode;
+  updatePrevFacingMode(prevFacingMode);
+  currentFacingMode = currentFacingMode === "environment" ? "user" : "environment";
+  updateCurrentFacingMode(currentFacingMode);
+  updateIsMediaSettingsModalVisible(false);
+  await switchUserVideoAlt({
+    videoPreference: currentFacingMode,
+    checkoff,
+    parameters
+  });
+};
+const getModalPosition = ({ position }) => {
+  switch (position) {
+    case "center":
+      return { justifyContent: "center", alignItems: "center" };
+    case "topLeft":
+      return { justifyContent: "flex-start", alignItems: "flex-start" };
+    case "topRight":
+      return { justifyContent: "flex-start", alignItems: "flex-end" };
+    case "bottomLeft":
+      return { justifyContent: "flex-end", alignItems: "flex-start" };
+    case "bottomRight":
+    default:
+      return { justifyContent: "flex-end", alignItems: "flex-end" };
+  }
+};
+const launchWaiting = ({ updateIsWaitingModalVisible, isWaitingModalVisible }) => {
+  updateIsWaitingModalVisible(!isWaitingModalVisible);
+};
+const respondToWaiting = async ({
+  participantId,
+  participantName,
+  updateWaitingList,
+  waitingList = [],
+  type,
+  roomName,
+  socket
+}) => {
+  if (!participantId || !participantName) {
+    return;
+  }
+  if (!updateWaitingList) {
+    console.warn("[respondToWaiting] Missing updateWaitingList handler; aborting emit.");
+    return;
+  }
+  if (!socket || typeof socket.emit !== "function") {
+    console.warn("[respondToWaiting] Socket is not ready; skipping emit.");
+    return;
+  }
+  const newWaitingList = waitingList.filter((item) => item.name !== participantName);
+  updateWaitingList(newWaitingList);
+  const responseType = type === "true" || type === true ? "true" : "false";
+  socket.emit("allowUserIn", {
+    participantId,
+    participantName,
+    type: responseType,
+    roomName
+  });
+};
+const handleStartWhiteboard = async ({
+  socket,
+  whiteboardUsers,
+  roomName,
+  whiteboardStarted,
+  whiteboardEnded,
+  showAlert,
+  updateWhiteboardStarted,
+  updateWhiteboardEnded,
+  updateIsConfigureWhiteboardModalVisible
+}) => {
+  const emitName = whiteboardStarted && !whiteboardEnded ? "updateWhiteboard" : "startWhiteboard";
+  const filteredWhiteboardUsers = whiteboardUsers.map(({ name, useBoard }) => ({ name, useBoard }));
+  return new Promise((resolve) => {
+    socket.emit(
+      emitName,
+      { whiteboardUsers: filteredWhiteboardUsers, roomName },
+      (response) => {
+        if (response.success) {
+          showAlert?.({ message: "Whiteboard active", type: "success" });
+          updateWhiteboardStarted(true);
+          updateWhiteboardEnded(false);
+          updateIsConfigureWhiteboardModalVisible(false);
+        } else {
+          showAlert?.({ message: response.reason || "Failed to start whiteboard", type: "danger" });
+        }
+        resolve(response.success);
+      }
+    );
+  });
+};
+const handleStopWhiteboard = async ({
+  socket,
+  roomName,
+  showAlert,
+  updateWhiteboardStarted,
+  updateWhiteboardEnded,
+  updateIsConfigureWhiteboardModalVisible
+}) => {
+  return new Promise((resolve) => {
+    socket.emit("stopWhiteboard", { roomName }, (response) => {
+      if (response.success) {
+        showAlert?.({ message: "Whiteboard stopped", type: "success" });
+        updateWhiteboardStarted(false);
+        updateWhiteboardEnded(true);
+        updateIsConfigureWhiteboardModalVisible(false);
+      } else {
+        showAlert?.({ message: response.reason || "Failed to stop whiteboard", type: "danger" });
+      }
+      resolve(response.success);
+    });
+  });
+};
+const launchConfigureWhiteboard = ({
+  updateIsConfigureWhiteboardModalVisible,
+  isConfigureWhiteboardModalVisible
+}) => {
+  updateIsConfigureWhiteboardModalVisible(!isConfigureWhiteboardModalVisible);
+};
+function getRoomReadiness({ parameters }) {
+  const source = parameters || {};
+  if (!source.roomName) {
+    return { ready: false, reason: "Waiting for the room name." };
+  }
+  if (!source.member) {
+    return { ready: false, reason: "Waiting for the participant identity." };
+  }
+  if (source.validated !== true) {
+    return { ready: false, reason: "Waiting for MediaSFU to validate the room." };
+  }
+  const socket = source.socket;
+  if (!socket || socket.connected !== true) {
+    return { ready: false, reason: "Connecting to the MediaSFU room." };
+  }
+  if (typeof socket.emit !== "function") {
+    return { ready: false, reason: "The room signal is not ready yet." };
+  }
+  if (source.device?.loaded !== true) {
+    return { ready: false, reason: "Waiting for the MediaSFU media device." };
+  }
+  return { ready: true, reason: "" };
+}
+const SELF_PRODUCER_IDS = /* @__PURE__ */ new Set(["youyou", "youyouyou"]);
+function toMediaStream(value) {
+  if (value && typeof value.getTracks === "function") return value;
+  const nested = value?.stream;
+  return nested && typeof nested.getTracks === "function" ? nested : null;
+}
+function hasRenderableTrack(stream, kind, requireEnabled) {
+  if (!stream || typeof stream.getTracks !== "function") return false;
+  try {
+    return stream.getTracks().some(
+      (track) => track.kind === kind && track.readyState === "live" && (!requireEnabled || track.enabled !== false)
+    );
+  } catch {
+    return false;
+  }
+}
+function collect(entries) {
+  return Array.isArray(entries) ? entries : [];
+}
+function dedupe(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = [];
+  for (const entry of entries) {
+    const producerId = entry?.producerId || "";
+    if (SELF_PRODUCER_IDS.has(producerId)) continue;
+    const stream = toMediaStream(entry);
+    if (!hasRenderableTrack(stream, "video", false)) continue;
+    const key = producerId || stream.id || "";
+    if (key && seen.has(key)) continue;
+    if (key) seen.add(key);
+    resolved.push({
+      stream,
+      producerId,
+      name: entry?.name || ""
+    });
+  }
+  return resolved;
+}
+function getRemoteVideoStreams({
+  parameters
+}) {
+  const source = parameters || {};
+  return dedupe([
+    ...collect(source.oldAllStreams),
+    ...collect(source.allVideoStreams)
+  ]);
+}
+function getRemoteAudioStreams({
+  parameters
+}) {
+  const source = parameters || {};
+  return dedupe(collect(source.allAudioStreams));
+}
+function getLocalVideoStream({
+  parameters
+}) {
+  const source = parameters || {};
+  if (source.keepBackground && source.virtualStream) {
+    const virtual = toMediaStream(source.virtualStream);
+    if (hasRenderableTrack(virtual, "video", true)) return virtual;
+  }
+  const camera = toMediaStream(source.localStreamVideo);
+  if (hasRenderableTrack(camera, "video", true)) return camera;
+  const combined = toMediaStream(source.localStream);
+  return hasRenderableTrack(combined, "video", true) ? combined : null;
+}
+function getLocalAudioStream({
+  parameters
+}) {
+  const source = parameters || {};
+  const mic = toMediaStream(source.localStreamAudio);
+  if (hasRenderableTrack(mic, "audio", true)) return mic;
+  const combined = toMediaStream(source.localStream);
+  return hasRenderableTrack(combined, "audio", true) ? combined : null;
+}
+function getScreenShareStream({
+  parameters
+}) {
+  const source = parameters || {};
+  const remoteRaw = source.remoteScreenStream;
+  const remote = Array.isArray(remoteRaw) ? toMediaStream(remoteRaw[0]) : toMediaStream(remoteRaw);
+  if (hasRenderableTrack(remote, "video", false)) {
+    return { stream: remote, isLocal: false, active: true };
+  }
+  const local = toMediaStream(source.localStreamScreen);
+  if (hasRenderableTrack(local, "video", true)) {
+    return { stream: local, isLocal: true, active: true };
+  }
+  return {
+    stream: null,
+    isLocal: false,
+    active: Boolean(source.shareScreenStarted || source.shared)
+  };
+}
+function getAudioGridComponents({ parameters }) {
+  const source = parameters || {};
+  return [
+    ...Array.isArray(source.audioOnlyStreams) ? source.audioOnlyStreams : [],
+    ...Array.isArray(source.translationStreams) ? source.translationStreams : []
+  ].filter(Boolean);
+}
+function getCurrentParams({
+  parameters
+}) {
+  const source = parameters || {};
+  if (typeof source.getCurrentParams === "function") {
+    try {
+      const refreshed = source.getCurrentParams();
+      if (refreshed && typeof refreshed === "object") return refreshed;
+    } catch {
+    }
+  }
+  return source;
+}
+function usableSocket(parameters) {
+  return [parameters?.localSocket, parameters?.socket].find(
+    (socket) => socket?.connected === true && typeof socket.emit === "function"
+  ) || null;
+}
+async function leaveRoom({
+  parameters,
+  ban = false,
+  endRoomOnHostExit = true
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    const socket = live?.socket;
+    if (!socket || typeof socket.emit !== "function") {
+      return {
+        ok: false,
+        error: "Room exit is unavailable until the signaling connection is ready."
+      };
+    }
+    if (!live?.member || !live?.roomName) {
+      return { ok: false, error: "Room exit is unavailable until the room is joined." };
+    }
+    await confirmExit({
+      socket,
+      localSocket: live.localSocket,
+      member: live.member,
+      roomName: live.roomName,
+      ban,
+      endRoomOnHostExit
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The room exit request failed." };
+  }
+}
+async function sendChatMessage({
+  parameters,
+  message,
+  receivers = [],
+  group
+}) {
+  try {
+    const trimmed = String(message ?? "").trim();
+    if (!trimmed) return { ok: false, error: "The message is empty." };
+    const live = getCurrentParams({ parameters });
+    const socket = usableSocket(live);
+    if (!socket) {
+      return { ok: false, error: "Chat is unavailable until the room connection is ready." };
+    }
+    if (!live?.roomName) {
+      return { ok: false, error: "Chat is unavailable until the room is joined." };
+    }
+    await sendMessage({
+      member: live.member || "",
+      islevel: live.islevel || "1",
+      showAlert: live.showAlert,
+      coHostResponsibility: live.coHostResponsibility || [],
+      coHost: live.coHost || "",
+      chatSetting: live.chatSetting || "",
+      message: trimmed,
+      roomName: live.roomName,
+      messagesLength: Array.isArray(live.messages) ? live.messages.length : 0,
+      receivers,
+      group: group ?? receivers.length === 0,
+      sender: live.member || "",
+      socket
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The message could not be sent." };
+  }
+}
+async function runMediaControl({
+  parameters,
+  control,
+  extra
+}) {
+  const live = getCurrentParams({ parameters });
+  const readiness = getRoomReadiness({ parameters: live });
+  if (!readiness.ready) return { ok: false, error: readiness.reason };
+  const method = live?.[control];
+  if (typeof method !== "function") {
+    return { ok: false, error: `The SDK ${control} control is unavailable.` };
+  }
+  const alertBefore = live?.alertMessage || "";
+  try {
+    await method({ ...extra || {}, parameters: live });
+  } catch (error) {
+    return { ok: false, error: error?.message || "The media control failed." };
+  }
+  const settled = getCurrentParams({ parameters: live });
+  const alertAfter = settled?.alertMessage || "";
+  const alertType = settled?.alertType;
+  if (alertAfter && alertAfter !== alertBefore && (alertType === "danger" || alertType === "warning")) {
+    return { ok: false, error: alertAfter };
+  }
+  return { ok: true, error: "" };
+}
+function hasProducer(value) {
+  return typeof value === "string" && value.length > 3 && value.toLowerCase() !== "none";
+}
+function participantList$1(parameters) {
+  const source = parameters || {};
+  const primary = Array.isArray(source.participants) ? source.participants : [];
+  if (primary.length > 0) return primary;
+  return Array.isArray(source.participantsAll) ? source.participantsAll : [];
+}
+function getParticipantMediaState({
+  parameters,
+  name = "",
+  id = ""
+}) {
+  const source = parameters || {};
+  const participants = participantList$1(source);
+  const participant = (id ? participants.find((part) => part.id === id) : void 0) || (name ? participants.find((part) => part.name === name) : void 0) || null;
+  const videoProducerId = hasProducer(participant?.videoID) ? participant.videoID : "";
+  const audioProducerId = hasProducer(participant?.audioID) ? participant.audioID : "";
+  return {
+    participant,
+    name: participant?.name || "",
+    isSelf: Boolean(participant?.name && participant.name === source.member),
+    isHost: String(participant?.islevel) === "2",
+    hasVideo: Boolean(videoProducerId),
+    hasAudio: Boolean(audioProducerId),
+    muted: participant?.muted === true,
+    videoProducerId,
+    audioProducerId
+  };
+}
+function listParticipantMediaStates({
+  parameters
+}) {
+  const source = parameters || {};
+  return participantList$1(source).map(
+    (participant) => getParticipantMediaState({
+      parameters: source,
+      id: participant.id,
+      name: participant.name
+    })
+  );
+}
+function getActiveSpeaker({ parameters }) {
+  const source = parameters || {};
+  const decibels = Array.isArray(source.audioDecibels) ? source.audioDecibels : [];
+  const participants = participantList$1(source);
+  let best = null;
+  for (const entry of decibels) {
+    if (!entry?.name || typeof entry.averageLoudness !== "number") continue;
+    if (entry.averageLoudness <= 127.5) continue;
+    if (!best || entry.averageLoudness > best.averageLoudness) best = entry;
+  }
+  if (!best) return { name: "", level: 0, participant: null };
+  return {
+    name: best.name,
+    level: best.averageLoudness,
+    participant: participants.find((part) => part.name === best.name) || null
+  };
+}
+async function listMediaDevices({
+  parameters
+}) {
+  const source = parameters || {};
+  try {
+    if (typeof source.getMediaDevicesList === "function") {
+      const [cameras, microphones] = await Promise.all([
+        source.getMediaDevicesList("videoinput"),
+        source.getMediaDevicesList("audioinput")
+      ]);
+      return {
+        cameras: Array.isArray(cameras) ? cameras : [],
+        microphones: Array.isArray(microphones) ? microphones : []
+      };
+    }
+    const devices = await navigator.mediaDevices.enumerateDevices();
+    return {
+      cameras: devices.filter((device) => device.kind === "videoinput"),
+      microphones: devices.filter((device) => device.kind === "audioinput")
+    };
+  } catch {
+    return { cameras: [], microphones: [] };
+  }
+}
+function getSelectedDevices({ parameters }) {
+  const source = parameters || {};
+  return {
+    cameraId: source.userDefaultVideoInputDevice || "",
+    microphoneId: source.userDefaultAudioInputDevice || "",
+    cameras: Array.isArray(source.videoInputs) ? source.videoInputs : [],
+    microphones: Array.isArray(source.audioInputs) ? source.audioInputs : []
+  };
+}
+function isPanelist(parameters) {
+  const panelists = Array.isArray(parameters.panelists) ? parameters.panelists : [];
+  return panelists.some((entry) => entry?.name === parameters.member);
+}
+function getMediaPermissions({ parameters }) {
+  const source = parameters || {};
+  const isHost = String(source.islevel) === "2";
+  const recording = Boolean(source.recordStarted || source.recordResumed) && !(source.recordPaused || source.recordStopped);
+  const focusModeBlocked = Boolean(source.panelistsFocused) && !isHost && !isPanelist(source);
+  const evaluate = (kind) => {
+    const allow = () => ({ allowed: true, reason: "", needsApproval: false });
+    const deny = (reason) => ({ allowed: false, reason, needsApproval: false });
+    if (source.audioOnlyRoom && kind !== "audio") {
+      return deny("This is an audio-only event.");
+    }
+    if (isHost && recording) {
+      if (kind === "audio" && source.recordingMediaOptions === "audio") {
+        return deny("Pause or stop the recording before changing your microphone.");
+      }
+      if (kind === "video" && source.recordingMediaOptions === "video") {
+        return deny("Pause or stop the recording before changing your camera.");
+      }
+    }
+    if (isHost) return allow();
+    if (source.adminRestrictSetting) {
+      return deny("Access denied by the host.");
+    }
+    if (focusModeBlocked && kind === "audio" && source.muteOthersMic) {
+      return deny("Only panelists can unmute while focus mode is active.");
+    }
+    if (focusModeBlocked && kind === "video" && source.muteOthersCamera) {
+      return deny("Only panelists can enable video while focus mode is active.");
+    }
+    const setting = kind === "audio" ? source.audioSetting : kind === "video" ? source.videoSetting : source.screenshareSetting;
+    if (setting === "disallow") {
+      return deny("The host has disabled this for participants.");
+    }
+    if (setting === "approval") {
+      return { allowed: true, reason: "The host must approve this.", needsApproval: true };
+    }
+    return allow();
+  };
+  return {
+    microphone: evaluate("audio"),
+    camera: evaluate("video"),
+    screenShare: evaluate("screenshare"),
+    isHost,
+    focusModeBlocked
+  };
+}
+function hasResponsibility(parameters, area) {
+  const list = Array.isArray(parameters?.coHostResponsibility) ? parameters.coHostResponsibility : [];
+  return list.find((item) => item?.name === area)?.value === true;
+}
+function getModerationPermissions({
+  parameters
+}) {
+  const source = parameters || {};
+  const isHost = String(source.islevel) === "2";
+  const isCoHost = Boolean(source.coHost && source.coHost === source.member);
+  const allow = (area) => isHost || isCoHost && hasResponsibility(source, area);
+  return {
+    isHost,
+    isCoHost,
+    canControlMedia: allow("media"),
+    canManageParticipants: allow("participants"),
+    canManageChat: allow("chat"),
+    canManageWaitingRoom: allow("waiting")
+  };
+}
+function participantList(parameters) {
+  const source = parameters || {};
+  const primary = Array.isArray(source.participants) ? source.participants : [];
+  if (primary.length > 0) return primary;
+  return Array.isArray(source.participantsAll) ? source.participantsAll : [];
+}
+function findParticipant(parameters, { id, name }) {
+  const participants = participantList(parameters);
+  return (id ? participants.find((part) => part.id === id) : void 0) || (name ? participants.find((part) => part.name === name) : void 0) || null;
+}
+async function setParticipantMedia({
+  parameters,
+  name = "",
+  id = "",
+  kind
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    const permissions = getModerationPermissions({ parameters: live });
+    if (!permissions.canControlMedia) {
+      return {
+        ok: false,
+        error: "You are not allowed to control media for other participants."
+      };
+    }
+    const socket = live?.socket;
+    if (!socket || typeof socket.emit !== "function" || !live?.roomName) {
+      return { ok: false, error: "The room connection is not ready." };
+    }
+    const participant = findParticipant(live, { id, name });
+    if (!participant) return { ok: false, error: "That participant is not in the room." };
+    if (String(participant.islevel) === "2") {
+      return { ok: false, error: "A host’s media cannot be turned off." };
+    }
+    socket.emit("controlMedia", {
+      participantId: participant.id,
+      participantName: participant.name,
+      type: kind,
+      roomName: live.roomName
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The media control failed." };
+  }
+}
+function muteParticipant(options) {
+  return setParticipantMedia({ ...options, kind: "audio" });
+}
+function disableParticipantVideo(options) {
+  return setParticipantMedia({ ...options, kind: "video" });
+}
+function stopParticipantScreenShare(options) {
+  return setParticipantMedia({ ...options, kind: "screenshare" });
+}
+async function muteEveryone({
+  parameters,
+  kind = "audio"
+}) {
+  const live = getCurrentParams({ parameters });
+  const permissions = getModerationPermissions({ parameters: live });
+  if (!permissions.canControlMedia) {
+    return {
+      ok: false,
+      error: "You are not allowed to control media for other participants."
+    };
+  }
+  const targets = participantList(live).filter(
+    (part) => String(part.islevel) !== "2" && part.name !== live.member
+  );
+  if (targets.length === 0) return { ok: false, error: "There is nobody else to mute." };
+  const results = await Promise.all(
+    targets.map(
+      (part) => setParticipantMedia({ parameters: live, id: part.id, name: part.name, kind })
+    )
+  );
+  const failed = results.filter((result) => !result.ok);
+  if (failed.length === results.length) {
+    return { ok: false, error: failed[0]?.error || "No participant could be muted." };
+  }
+  return { ok: true, error: "" };
+}
+async function removeParticipant({
+  parameters,
+  name = "",
+  id = ""
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    const permissions = getModerationPermissions({ parameters: live });
+    if (!permissions.canManageParticipants) {
+      return { ok: false, error: "You are not allowed to remove participants." };
+    }
+    const participant = findParticipant(live, { id, name });
+    if (!participant) return { ok: false, error: "That participant is not in the room." };
+    if (String(participant.islevel) === "2") {
+      return { ok: false, error: "A host cannot be removed." };
+    }
+    await removeParticipants({
+      coHostResponsibility: live.coHostResponsibility || [],
+      participant,
+      member: live.member || "",
+      islevel: live.islevel || "1",
+      showAlert: live.showAlert,
+      coHost: live.coHost || "",
+      participants: participantList(live),
+      socket: live.socket,
+      roomName: live.roomName || "",
+      updateParticipants: live.updateParticipants
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The participant could not be removed." };
+  }
+}
+async function respondToWaitingParticipant({
+  parameters,
+  name = "",
+  id = "",
+  admit
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    const permissions = getModerationPermissions({ parameters: live });
+    if (!permissions.canManageWaitingRoom) {
+      return { ok: false, error: "You are not allowed to manage the waiting room." };
+    }
+    const waitingList = Array.isArray(live.waitingRoomList) ? live.waitingRoomList : [];
+    const entry = (id ? waitingList.find((person) => person?.id === id) : void 0) || (name ? waitingList.find((person) => person?.name === name) : void 0);
+    if (!entry) return { ok: false, error: "That person is no longer waiting to join." };
+    await respondToWaiting({
+      participantId: entry.id,
+      participantName: entry.name,
+      updateWaitingList: live.updateWaitingRoomList,
+      waitingList,
+      type: admit,
+      roomName: live.roomName || "",
+      socket: live.socket
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error?.message || "The waiting-room response failed."
+    };
+  }
+}
+async function respondToParticipantRequest({
+  parameters,
+  requestId = "",
+  name = "",
+  approve
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    const permissions = getModerationPermissions({ parameters: live });
+    if (!permissions.canManageParticipants) {
+      return { ok: false, error: "You are not allowed to respond to requests." };
+    }
+    const requestList = Array.isArray(live.requestList) ? live.requestList : [];
+    const request = (requestId ? requestList.find((item) => item?.id === requestId) : void 0) || (name ? requestList.find(
+      (item) => item?.name === name || item?.username === name
+    ) : void 0);
+    if (!request) return { ok: false, error: "That request is no longer pending." };
+    await respondToRequests({
+      socket: live.socket,
+      request,
+      updateRequestList: live.updateRequestList,
+      requestList,
+      action: approve ? "accepted" : "rejected",
+      roomName: live.roomName || ""
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The request response failed." };
+  }
+}
+async function setCoHost({
+  parameters,
+  name,
+  areas = ["media", "participants"]
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    if (String(live.islevel) !== "2") {
+      return { ok: false, error: "Only the host can assign a co-host." };
+    }
+    const all = ["media", "participants", "chat", "waiting"];
+    const responsibilities = all.map((area) => ({
+      name: area,
+      value: areas.includes(area),
+      dedicated: false
+    }));
+    await modifyCoHostSettings({
+      roomName: live.roomName || "",
+      showAlert: live.showAlert,
+      selectedParticipant: name,
+      coHost: live.coHost || "",
+      coHostResponsibility: responsibilities,
+      updateIsCoHostModalVisible: live.updateIsCoHostModalVisible || (() => void 0),
+      updateCoHostResponsibility: live.updateCoHostResponsibility,
+      updateCoHost: live.updateCoHost,
+      socket: live.socket
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The co-host update failed." };
+  }
+}
+const noop = () => void 0;
+function getRecordingState({ parameters }) {
+  const source = parameters || {};
+  const canRecord = source.canRecord === true;
+  let status = "idle";
+  if (!canRecord && !source.recordStarted) status = "unavailable";
+  else if (source.recordStopped) status = "stopped";
+  else if (source.recordStarted && source.recordPaused) status = "paused";
+  else if (source.recordStarted) status = "recording";
+  return {
+    status,
+    active: status === "recording",
+    canRecord,
+    mediaOptions: source.recordingMediaOptions || "video",
+    elapsedSeconds: Number(source.recordElapsedTime) || 0
+  };
+}
+async function startRoomRecording({
+  parameters
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    if (live.canRecord !== true) {
+      return { ok: false, error: "Recording is not available in this room." };
+    }
+    if (live.recordStarted && !live.recordStopped) {
+      return { ok: false, error: "Recording has already started." };
+    }
+    await confirmRecording({ parameters: live });
+    const refreshed = getCurrentParams({ parameters: live });
+    await startRecording({ parameters: refreshed });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "Recording could not be started." };
+  }
+}
+async function pauseRoomRecording({
+  parameters
+}) {
+  return toggleRecordingPause(parameters, true);
+}
+async function resumeRoomRecording({
+  parameters
+}) {
+  return toggleRecordingPause(parameters, false);
+}
+async function toggleRecordingPause(parameters, pause) {
+  try {
+    const live = getCurrentParams({ parameters });
+    const state = getRecordingState({ parameters: live });
+    if (state.status !== (pause ? "recording" : "paused")) {
+      return {
+        ok: false,
+        error: pause ? "There is no active recording to pause." : "There is no paused recording to resume."
+      };
+    }
+    await updateRecording({ parameters: live });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error?.message || "The recording state could not be changed."
+    };
+  }
+}
+async function stopRoomRecording({
+  parameters
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    if (!live.recordStarted || live.recordStopped) {
+      return { ok: false, error: "There is no active recording to stop." };
+    }
+    await stopRecording({ parameters: live });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "Recording could not be stopped." };
+  }
+}
+function getWhiteboardState({ parameters }) {
+  const source = parameters || {};
+  return {
+    active: source.whiteboardStarted === true && source.whiteboardEnded !== true,
+    canStart: source.canStartWhiteboard === true,
+    users: Array.isArray(source.whiteboardUsers) ? source.whiteboardUsers : [],
+    limit: Number(source.whiteboardLimit) || 0,
+    canvas: source.canvasWhiteboard || null
+  };
+}
+async function startWhiteboard({
+  parameters,
+  users
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    if (live.breakOutRoomStarted && !live.breakOutRoomEnded) {
+      return {
+        ok: false,
+        error: "The whiteboard cannot start while breakout rooms are active."
+      };
+    }
+    const socket = live?.socket;
+    if (!socket || typeof socket.emit !== "function" || !live?.roomName) {
+      return { ok: false, error: "The room connection is not ready." };
+    }
+    const state = getWhiteboardState({ parameters: live });
+    if (!state.active && !state.canStart) {
+      return { ok: false, error: "You are not allowed to start the whiteboard." };
+    }
+    const whiteboardUsers = users ?? state.users;
+    if (state.limit > 0 && whiteboardUsers.length > state.limit) {
+      return {
+        ok: false,
+        error: `The whiteboard allows at most ${state.limit} participants.`
+      };
+    }
+    const event = state.active ? "updateWhiteboard" : "startWhiteboard";
+    const response = await new Promise((resolve) => {
+      socket.emit(event, { whiteboardUsers, roomName: live.roomName }, resolve);
+    });
+    if (!response?.success) {
+      return {
+        ok: false,
+        error: response?.reason || "The whiteboard could not be started."
+      };
+    }
+    live.updateWhiteboardStarted?.(true);
+    live.updateWhiteboardEnded?.(false);
+    live.updateWhiteboardUsers?.(whiteboardUsers);
+    live.updateCanStartWhiteboard?.(false);
+    return { ok: true, error: "" };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error?.message || "The whiteboard could not be started."
+    };
+  }
+}
+async function stopWhiteboard({
+  parameters
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    const socket = live?.socket;
+    if (!socket || typeof socket.emit !== "function" || !live?.roomName) {
+      return { ok: false, error: "The room connection is not ready." };
+    }
+    if (!getWhiteboardState({ parameters: live }).active) {
+      return { ok: false, error: "The whiteboard is not running." };
+    }
+    const response = await new Promise((resolve) => {
+      socket.emit("stopWhiteboard", { roomName: live.roomName }, resolve);
+    });
+    if (!response?.success) {
+      return {
+        ok: false,
+        error: response?.reason || "The whiteboard could not be stopped."
+      };
+    }
+    live.updateWhiteboardStarted?.(false);
+    live.updateWhiteboardEnded?.(true);
+    return { ok: true, error: "" };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error?.message || "The whiteboard could not be stopped."
+    };
+  }
+}
+function getPollState({ parameters }) {
+  const source = parameters || {};
+  const polls = Array.isArray(source.polls) ? source.polls : [];
+  const active = source.poll && source.poll.status === "active" ? source.poll : polls.find((entry) => entry?.status === "active") || null;
+  return { polls, active };
+}
+async function createRoomPoll({
+  parameters,
+  question,
+  options,
+  type = "custom"
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    if (!question?.trim()) return { ok: false, error: "The poll needs a question." };
+    if (!Array.isArray(options) || options.length < 2) {
+      return { ok: false, error: "The poll needs at least two options." };
+    }
+    await handleCreatePoll({
+      poll: { question, options, type },
+      socket: live.socket,
+      roomName: live.roomName || "",
+      showAlert: live.showAlert,
+      updateIsPollModalVisible: live.updateIsPollModalVisible || noop
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The poll could not be created." };
+  }
+}
+async function voteInRoomPoll({
+  parameters,
+  pollId,
+  optionIndex
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    await handleVotePoll({
+      pollId,
+      optionIndex,
+      socket: live.socket,
+      showAlert: live.showAlert,
+      member: live.member || "",
+      roomName: live.roomName || "",
+      updateIsPollModalVisible: live.updateIsPollModalVisible || noop
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The vote could not be cast." };
+  }
+}
+async function endRoomPoll({
+  parameters,
+  pollId
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    if (String(live.islevel) !== "2") {
+      return { ok: false, error: "Only the host can end a poll." };
+    }
+    await handleEndPoll({
+      pollId,
+      socket: live.socket,
+      showAlert: live.showAlert,
+      roomName: live.roomName || "",
+      updateIsPollModalVisible: live.updateIsPollModalVisible || noop
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The poll could not be ended." };
+  }
+}
+function getBreakoutState({ parameters }) {
+  const source = parameters || {};
+  return {
+    active: source.breakOutRoomStarted === true && source.breakOutRoomEnded !== true,
+    canStart: source.canStartBreakout === true,
+    rooms: Array.isArray(source.breakoutRooms) ? source.breakoutRooms : [],
+    currentRoom: typeof source.hostNewRoom === "number" ? source.hostNewRoom : -1
+  };
+}
+function getRecordingNotice({ parameters }) {
+  const source = parameters || {};
+  const isAudio = source.recordingMediaOptions === "audio";
+  const pauseLimit = Number(
+    isAudio ? source.recordingAudioPausesLimit : source.recordingVideoPausesLimit
+  ) || 0;
+  const pausesUsed = Number(source.pauseRecordCount) || 0;
+  return {
+    message: source.recordingNotice || "",
+    elapsed: source.recordingProgressTime || "00:00:00",
+    elapsedSeconds: Number(source.recordElapsedTime) || 0,
+    canPauseResume: source.canPauseResume === true,
+    pausesUsed,
+    pauseLimit,
+    pauseLimitReached: pauseLimit > 0 && pausesUsed >= pauseLimit
+  };
+}
+function getRecordingCapabilities({
+  parameters
+}) {
+  const source = parameters || {};
+  return {
+    audio: source.recordingAudioSupport === true,
+    video: source.recordingVideoSupport === true,
+    allParticipants: source.recordingAllParticipantsSupport === true,
+    videoParticipants: source.recordingVideoParticipantsSupport === true,
+    hls: source.recordingAddHLS === true,
+    audioPeopleLimit: Number(source.recordingAudioPeopleLimit) || 0,
+    videoPeopleLimit: Number(source.recordingVideoPeopleLimit) || 0
+  };
+}
+function getTranslationState({ parameters }) {
+  const source = parameters || {};
+  const preferences = source.listenerTranslationPreferences || {};
+  const perSpeakerMap = preferences.perSpeaker;
+  const perSpeaker = perSpeakerMap instanceof Map ? Array.from(perSpeakerMap.values()) : Array.isArray(perSpeakerMap) ? perSpeakerMap : [];
+  const speakerStates = source.speakerTranslationStates;
+  const languages = /* @__PURE__ */ new Set();
+  const collect2 = (value) => {
+    if (value?.language) languages.add(value.language);
+  };
+  if (speakerStates instanceof Map) speakerStates.forEach(collect2);
+  else if (Array.isArray(speakerStates)) speakerStates.forEach(collect2);
+  perSpeaker.forEach(collect2);
+  if (preferences.globalLanguage) languages.add(preferences.globalLanguage);
+  return {
+    globalLanguage: preferences.globalLanguage ?? null,
+    perSpeaker,
+    active: Boolean(
+      preferences.globalLanguage || perSpeaker.some((entry) => entry?.language && !entry.wantOriginal)
+    ),
+    availableLanguages: Array.from(languages)
+  };
+}
+function setTranslationPreference({
+  parameters,
+  language = null,
+  speakerId,
+  wantOriginal = false
+}) {
+  const source = parameters || {};
+  const update = source.updateListenerTranslationPreferences;
+  if (typeof update !== "function") {
+    return { ok: false, error: "Translation is not available in this room." };
+  }
+  try {
+    const current = source.listenerTranslationPreferences || {};
+    const perSpeaker = current.perSpeaker instanceof Map ? new Map(current.perSpeaker) : /* @__PURE__ */ new Map();
+    if (speakerId) {
+      perSpeaker.set(speakerId, { speakerId, language, wantOriginal });
+      update({ perSpeaker, globalLanguage: current.globalLanguage ?? null });
+    } else {
+      update({ perSpeaker, globalLanguage: language });
+    }
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The translation preference could not be set." };
+  }
+}
+function getFocusModeState({ parameters }) {
+  const source = parameters || {};
+  const panelists = Array.isArray(source.panelists) ? source.panelists : [];
+  return {
+    active: source.panelistsFocused === true,
+    panelists,
+    selfIsPanelist: panelists.some((entry) => entry?.name === source.member),
+    mutesMicrophones: source.muteOthersMic === true,
+    mutesCameras: source.muteOthersCamera === true
+  };
+}
+function getVirtualBackgroundState({
+  parameters
+}) {
+  const source = parameters || {};
+  const stream = source.virtualStream || source.processedStream;
+  return {
+    active: source.keepBackground === true && Boolean(stream),
+    stream: stream || null,
+    appliedBackground: source.appliedBackground ?? null,
+    selectedImage: source.selectedImage ?? null
+  };
+}
+const LOCALLY_PAUSED = /* @__PURE__ */ new Set();
+async function setParticipantPlayback({
+  parameters,
+  name = "",
+  producerId = "",
+  kind = "all",
+  paused
+}) {
+  try {
+    const source = parameters || {};
+    const participants = Array.isArray(source.participants) ? source.participants : [];
+    const participant = name ? participants.find((part) => part?.name === name) : void 0;
+    const targets = /* @__PURE__ */ new Set();
+    if (producerId) targets.add(producerId);
+    const usable = (value) => typeof value === "string" && value.length > 3 && value.toLowerCase() !== "none";
+    if (participant) {
+      if (kind !== "video" && usable(participant.audioID)) targets.add(participant.audioID);
+      if (kind !== "audio" && usable(participant.videoID)) targets.add(participant.videoID);
+    }
+    if (targets.size === 0) {
+      return { ok: false, error: "That participant is not publishing anything to pause.", affected: 0 };
+    }
+    const transports = Array.isArray(source.consumerTransports) ? source.consumerTransports : [];
+    let affected = 0;
+    for (const entry of transports) {
+      const consumer = entry?.consumer;
+      const id = entry?.producerId || consumer?.producerId;
+      if (!consumer || !targets.has(id)) continue;
+      if (kind !== "all" && consumer.track?.kind !== kind) continue;
+      try {
+        if (paused && typeof consumer.pause === "function") {
+          await consumer.pause();
+          LOCALLY_PAUSED.add(id);
+          affected += 1;
+        } else if (!paused && typeof consumer.resume === "function") {
+          await consumer.resume();
+          LOCALLY_PAUSED.delete(id);
+          affected += 1;
+        }
+      } catch {
+      }
+    }
+    return affected > 0 ? { ok: true, error: "", affected } : { ok: false, error: "No matching incoming stream was found.", affected: 0 };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The playback change failed.", affected: 0 };
+  }
+}
+async function setBreakoutRooms({
+  parameters,
+  rooms,
+  newParticipantAction
+}) {
+  try {
+    const source = parameters || {};
+    const socket = source.socket;
+    if (!socket || typeof socket.emit !== "function" || !source.roomName) {
+      return { ok: false, error: "The room connection is not ready." };
+    }
+    if (String(source.islevel) !== "2") {
+      return { ok: false, error: "Only the host can change breakout rooms." };
+    }
+    const running = source.breakOutRoomStarted === true && source.breakOutRoomEnded !== true;
+    const event = running ? "updateBreakout" : "startBreakout";
+    const payload = (Array.isArray(rooms) ? rooms : []).map(
+      (room) => (Array.isArray(room) ? room : []).map(({ name, breakRoom }) => ({ name, breakRoom }))
+    );
+    const response = await new Promise((resolve) => {
+      socket.emit(
+        event,
+        {
+          breakoutRooms: payload,
+          newParticipantAction: newParticipantAction || source.newParticipantAction || "autoAssignNewRoom",
+          roomName: source.roomName
+        },
+        resolve
+      );
+    });
+    if (!response?.success) {
+      return { ok: false, error: response?.reason || "The breakout rooms could not be updated." };
+    }
+    source.updateBreakoutRooms?.(payload);
+    source.updateBreakOutRoomStarted?.(true);
+    source.updateBreakOutRoomEnded?.(false);
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The breakout rooms could not be updated." };
+  }
+}
+async function assignParticipantToBreakoutRoom({
+  parameters,
+  name,
+  room,
+  newParticipantAction
+}) {
+  const source = parameters || {};
+  if (!name) return { ok: false, error: "A participant name is required." };
+  const current = Array.isArray(source.breakoutRooms) ? source.breakoutRooms.map((entry) => Array.isArray(entry) ? [...entry] : []) : [];
+  const next = current.map((entry) => entry.filter((person) => person?.name !== name));
+  if (room !== null && room !== void 0) {
+    if (!Number.isInteger(room) || room < 0) {
+      return { ok: false, error: "The destination room must be a room index." };
+    }
+    while (next.length <= room) next.push([]);
+    next[room].push({ name, breakRoom: room });
+  }
+  return setBreakoutRooms({ parameters: source, rooms: next, newParticipantAction });
+}
+async function stopBreakoutRooms({
+  parameters
+}) {
+  try {
+    const source = parameters || {};
+    const socket = source.socket;
+    if (!socket || typeof socket.emit !== "function" || !source.roomName) {
+      return { ok: false, error: "The room connection is not ready." };
+    }
+    if (String(source.islevel) !== "2") {
+      return { ok: false, error: "Only the host can stop breakout rooms." };
+    }
+    const response = await new Promise((resolve) => {
+      socket.emit("stopBreakout", { roomName: source.roomName }, resolve);
+    });
+    if (!response?.success) {
+      return { ok: false, error: response?.reason || "The breakout rooms could not be stopped." };
+    }
+    source.updateBreakOutRoomStarted?.(false);
+    source.updateBreakOutRoomEnded?.(true);
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The breakout rooms could not be stopped." };
+  }
+}
+async function reapplyLocalPlayback({
+  parameters
+}) {
+  if (LOCALLY_PAUSED.size === 0) return { ok: true, error: "", affected: 0 };
+  try {
+    const source = parameters || {};
+    const transports = Array.isArray(source.consumerTransports) ? source.consumerTransports : [];
+    let affected = 0;
+    for (const entry of transports) {
+      const consumer = entry?.consumer;
+      const id = entry?.producerId || consumer?.producerId;
+      if (!consumer || !LOCALLY_PAUSED.has(id)) continue;
+      if (consumer.paused === true) continue;
+      try {
+        if (typeof consumer.pause === "function") {
+          await consumer.pause();
+          affected += 1;
+        }
+      } catch {
+      }
+    }
+    return { ok: true, error: "", affected };
+  } catch (error) {
+    return { ok: false, error: error?.message || "Playback could not be re-applied.", affected: 0 };
+  }
+}
+function getLocallyPausedProducerIds() {
+  return Array.from(LOCALLY_PAUSED);
+}
+async function invokeChecked(live, run) {
+  const alertBefore = live?.alertMessage || "";
+  try {
+    await run();
+  } catch (error) {
+    return { ok: false, error: error?.message || "The device switch failed." };
+  }
+  const settled = getCurrentParams({ parameters: live });
+  const alertAfter = settled?.alertMessage || "";
+  const alertType = settled?.alertType;
+  if (alertAfter && alertAfter !== alertBefore && (alertType === "danger" || alertType === "warning")) {
+    return { ok: false, error: alertAfter };
+  }
+  return { ok: true, error: "" };
+}
+async function switchCamera({
+  parameters,
+  deviceId
+}) {
+  if (!deviceId) return { ok: false, error: "A camera deviceId is required." };
+  const live = getCurrentParams({ parameters });
+  return invokeChecked(live, () => switchVideo({ videoPreference: deviceId, parameters: live }));
+}
+async function flipCamera({ parameters }) {
+  const live = getCurrentParams({ parameters });
+  return invokeChecked(live, () => switchVideoAlt({ parameters: live }));
+}
+async function switchMicrophone({
+  parameters,
+  deviceId
+}) {
+  if (!deviceId) return { ok: false, error: "A microphone deviceId is required." };
+  const live = getCurrentParams({ parameters });
+  return invokeChecked(live, () => switchAudio({ audioPreference: deviceId, parameters: live }));
+}
+async function setRoomMediaPolicy({
+  parameters,
+  audio,
+  video,
+  screenshare,
+  chat
+}) {
+  const live = getCurrentParams({ parameters });
+  if (String(live.islevel) !== "2") {
+    return { ok: false, error: "Only the host can change room settings." };
+  }
+  if (!live.socket) {
+    return { ok: false, error: "The room connection is not ready yet." };
+  }
+  try {
+    await joinLocalRoom.modifySettings({
+      roomName: live.roomName || "",
+      // The SDK requires all four on every call, so unspecified values are
+      // filled from current state — otherwise changing one would blank the rest.
+      audioSet: audio || live.audioSetting || "allow",
+      videoSet: video || live.videoSetting || "allow",
+      screenshareSet: screenshare || live.screenshareSetting || "allow",
+      chatSet: chat || live.chatSetting || "allow",
+      socket: live.socket,
+      showAlert: live.showAlert,
+      updateAudioSetting: live.updateAudioSetting,
+      updateVideoSetting: live.updateVideoSetting,
+      updateScreenshareSetting: live.updateScreenshareSetting,
+      updateChatSetting: live.updateChatSetting,
+      updateIsSettingsModalVisible: live.updateIsSettingsModalVisible || (() => {
+      })
+    });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The room settings could not be updated." };
+  }
+}
+function getChatMessages({
+  parameters,
+  scope = "all",
+  withPerson = ""
+}) {
+  const source = parameters || {};
+  const raw = Array.isArray(source.messages) ? source.messages : [];
+  const me = source.member || "";
+  return raw.map((entry) => {
+    const receivers = Array.isArray(entry?.receivers) ? entry.receivers : [];
+    return {
+      sender: entry?.sender || "",
+      message: entry?.message || "",
+      timestamp: entry?.timestamp || "",
+      receivers,
+      // MediaSFU marks group messages with an empty receivers list; anything
+      // addressed is a DM.
+      direct: receivers.length > 0,
+      mine: entry?.sender === me
+    };
+  }).filter((message) => {
+    if (scope === "group" && message.direct) return false;
+    if (scope === "direct" && !message.direct) return false;
+    if (withPerson) {
+      return message.sender === withPerson || message.receivers.includes(withPerson);
+    }
+    return true;
+  });
+}
+function getPendingApprovals({ parameters }) {
+  const source = parameters || {};
+  const waitingRaw = Array.isArray(source.waitingRoomList) ? source.waitingRoomList : [];
+  const requestRaw = Array.isArray(source.requestList) ? source.requestList : [];
+  const waiting = waitingRaw.map((entry) => ({
+    name: entry?.name || "",
+    id: entry?.id || ""
+  }));
+  const requests = requestRaw.map((entry) => ({
+    id: entry?.id || "",
+    name: entry?.name || "",
+    // 'fa-microphone' | 'fa-video' | 'fa-desktop' | 'fa-comments' — what they asked for.
+    icon: entry?.icon || "",
+    username: entry?.username || entry?.name || ""
+  }));
+  return { waiting, requests, total: waiting.length + requests.length };
+}
+function getSessionTimer({ parameters }) {
+  const source = parameters || {};
+  return {
+    elapsed: source.meetingProgressTime || "00:00",
+    presenceCheckPending: Boolean(source.isConfirmHereModalVisible)
+  };
+}
+function getPresenceCheck({ parameters }) {
+  const source = parameters || {};
+  return { pending: Boolean(source.isConfirmHereModalVisible) };
+}
+function confirmStillHere({ parameters }) {
+  const live = getCurrentParams({ parameters });
+  const update = live.updateIsConfirmHereModalVisible;
+  if (typeof update !== "function") {
+    return { ok: false, error: "The presence check control is unavailable." };
+  }
+  update(false);
+  return { ok: true, error: "" };
+}
+function getPlaybackSources({ parameters }) {
+  const source = parameters || {};
+  const sources = [];
+  const push = (protocol, url) => {
+    if (typeof url === "string" && /^https:\/\//i.test(url)) sources.push({ protocol, url });
+  };
+  push("hls", source.hlsUrl || source.hlsPlaybackUrl || source.playbackUrl);
+  push("whep", source.whepUrl || source.whepPlaybackUrl);
+  return sources;
+}
+function inferProtocol(url, explicit) {
+  if (explicit) return explicit;
+  return /\.m3u8(\?|$)/i.test(url) ? "hls" : "whep";
+}
+function canPlayHlsNatively(video) {
+  const claimsSupport = typeof video.canPlayType === "function" && video.canPlayType("application/vnd.apple.mpegurl") !== "";
+  const hasMse = typeof MediaSource !== "undefined" || typeof globalThis.ManagedMediaSource !== "undefined";
+  return claimsSupport && !hasMse;
+}
+async function attachHls(url, video, hlsFactory) {
+  if (!video) throw new Error("HLS playback needs a <video> element.");
+  if (typeof hlsFactory !== "function" && canPlayHlsNatively(video)) {
+    video.src = url;
+    const play = video.play?.();
+    play?.catch?.(() => {
+    });
+    return {
+      protocol: "hls",
+      url,
+      stream: null,
+      detach: () => {
+        video.removeAttribute("src");
+        video.load?.();
+      }
+    };
+  }
+  if (typeof hlsFactory !== "function") {
+    throw new Error(
+      "HLS needs an hlsFactory on this browser. Pass () => new Hls(...) from hls.js; it is not bundled with the SDK. Only iOS Safari, which has no Media Source Extensions, plays HLS without one — Chrome reports that it can and then plays nothing."
+    );
+  }
+  const hls = hlsFactory();
+  hls.loadSource(url);
+  hls.attachMedia(video);
+  return {
+    protocol: "hls",
+    url,
+    stream: null,
+    detach: () => {
+      try {
+        hls.destroy();
+      } catch {
+      }
+      video.removeAttribute("src");
+    }
+  };
+}
+async function attachWhep(url, video, headers = {}, iceServers) {
+  if (typeof RTCPeerConnection === "undefined") {
+    throw new Error("WHEP playback needs WebRTC support.");
+  }
+  const pc = new RTCPeerConnection(iceServers?.length ? { iceServers } : void 0);
+  const stream = new MediaStream();
+  pc.addTransceiver("video", { direction: "recvonly" });
+  pc.addTransceiver("audio", { direction: "recvonly" });
+  pc.ontrack = (event) => {
+    if (event.track) stream.addTrack(event.track);
+    if (video && video.srcObject !== stream) {
+      video.srcObject = stream;
+      const play = video.play?.();
+      play?.catch?.(() => {
+      });
+    }
+  };
+  let resourceUrl = "";
+  try {
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/sdp", ...headers },
+      body: offer.sdp || ""
+    });
+    if (!response.ok) {
+      throw new Error(`The WHEP endpoint refused the request (${response.status}).`);
+    }
+    const location = response.headers.get("Location") || "";
+    resourceUrl = location ? new URL(location, url).toString() : "";
+    const answer = await response.text();
+    await pc.setRemoteDescription({ type: "answer", sdp: answer });
+  } catch (error) {
+    pc.close();
+    throw error;
+  }
+  return {
+    protocol: "whep",
+    url,
+    stream,
+    detach: () => {
+      if (resourceUrl) {
+        try {
+          void fetch(resourceUrl, { method: "DELETE", headers });
+        } catch {
+        }
+      }
+      try {
+        pc.close();
+      } catch {
+      }
+      stream.getTracks().forEach((track) => track.stop());
+      if (video && video.srcObject === stream) video.srcObject = null;
+    }
+  };
+}
+async function attachPlayback({
+  source,
+  video,
+  protocol,
+  hlsFactory,
+  headers,
+  iceServers
+}) {
+  const url = typeof source === "string" ? source : source?.url || "";
+  if (!url) throw new Error("A playback URL is required.");
+  const resolved = typeof source === "string" ? inferProtocol(url, protocol) : protocol || source.protocol || inferProtocol(url);
+  return resolved === "hls" ? attachHls(url, video, hlsFactory) : attachWhep(url, video, headers, iceServers);
+}
+function detachPlayback(handle) {
+  if (!handle || typeof handle.detach !== "function") return;
+  try {
+    handle.detach();
+  } catch {
+  }
+}
+async function publishWhip({
+  url,
+  stream,
+  headers = {},
+  iceServers
+}) {
+  if (typeof RTCPeerConnection === "undefined") {
+    throw new Error("WHIP publishing needs WebRTC support.");
+  }
+  if (!stream?.getTracks?.().length) throw new Error("A stream with at least one track is required.");
+  const pc = new RTCPeerConnection(iceServers?.length ? { iceServers } : void 0);
+  stream.getTracks().forEach((track) => pc.addTrack(track, stream));
+  let resourceUrl = "";
+  try {
+    const offer = await pc.createOffer();
+    await pc.setLocalDescription(offer);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/sdp", ...headers },
+      body: offer.sdp || ""
+    });
+    if (!response.ok) throw new Error(`The WHIP endpoint refused the request (${response.status}).`);
+    const location = response.headers.get("Location") || "";
+    resourceUrl = location ? new URL(location, url).toString() : "";
+    await pc.setRemoteDescription({ type: "answer", sdp: await response.text() });
+  } catch (error) {
+    pc.close();
+    throw error;
+  }
+  return {
+    protocol: "whep",
+    url,
+    stream,
+    detach: () => {
+      if (resourceUrl) {
+        try {
+          void fetch(resourceUrl, { method: "DELETE", headers });
+        } catch {
+        }
+      }
+      try {
+        pc.close();
+      } catch {
+      }
+    }
+  };
+}
+const MIN_INTERVAL_MS = 1e3;
+function createViewerSession({
+  provider,
+  roomName,
+  displayName,
+  pollIntervalMs = 5e3,
+  heartbeatIntervalMs = 3e4,
+  onChange
+}) {
+  let snapshot = {
+    phase: "idle",
+    session: null,
+    status: null,
+    error: "",
+    canRequestPromotion: typeof provider?.requestPromotion === "function"
+  };
+  let pollTimer = null;
+  let heartbeatTimer = null;
+  let stopped = false;
+  const emit = (next) => {
+    snapshot = { ...snapshot, ...next };
+    try {
+      onChange?.(snapshot);
+    } catch {
+    }
+  };
+  const clearTimers = () => {
+    if (pollTimer) {
+      clearInterval(pollTimer);
+      pollTimer = null;
+    }
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  };
+  const startTimers = () => {
+    clearTimers();
+    if (typeof provider.poll === "function") {
+      pollTimer = setInterval(async () => {
+        if (stopped || !snapshot.session) return;
+        try {
+          const status = await provider.poll({ session: snapshot.session });
+          if (stopped) return;
+          const session = status?.playbackUrl ? { ...snapshot.session, playbackUrl: status.playbackUrl } : snapshot.session;
+          emit({
+            status,
+            session,
+            phase: status?.approved ? "approved" : snapshot.phase === "requested" ? "requested" : "watching"
+          });
+          if (status?.approved) clearTimers();
+        } catch {
+        }
+      }, Math.max(MIN_INTERVAL_MS, pollIntervalMs));
+    }
+    if (typeof provider.heartbeat === "function") {
+      heartbeatTimer = setInterval(() => {
+        if (stopped || !snapshot.session) return;
+        Promise.resolve(provider.heartbeat({ session: snapshot.session })).catch(() => {
+        });
+      }, Math.max(MIN_INTERVAL_MS, heartbeatIntervalMs));
+    }
+  };
+  return {
+    getSnapshot: () => snapshot,
+    async start() {
+      if (snapshot.phase !== "idle" && snapshot.phase !== "left" && snapshot.phase !== "error") {
+        return snapshot;
+      }
+      stopped = false;
+      emit({ phase: "joining", error: "" });
+      try {
+        const session = await provider.join({ roomName, displayName });
+        if (stopped) return snapshot;
+        if (!session?.viewerId) throw new Error("The viewer session provider returned no viewerId.");
+        emit({ phase: "watching", session, error: "" });
+        startTimers();
+      } catch (error) {
+        emit({ phase: "error", error: error?.message || "The viewer session could not start." });
+      }
+      return snapshot;
+    },
+    async requestPromotion() {
+      if (!snapshot.session) {
+        emit({ error: "Start the viewer session before requesting the floor." });
+        return snapshot;
+      }
+      if (typeof provider.requestPromotion !== "function") {
+        emit({ error: "This viewer session provider does not support promotion." });
+        return snapshot;
+      }
+      try {
+        await provider.requestPromotion({ session: snapshot.session });
+        emit({ phase: "requested", error: "" });
+      } catch (error) {
+        emit({ error: error?.message || "The request could not be sent." });
+      }
+      return snapshot;
+    },
+    async stop() {
+      stopped = true;
+      clearTimers();
+      const session = snapshot.session;
+      emit({ phase: "left" });
+      if (session && typeof provider.leave === "function") {
+        try {
+          await provider.leave({ session });
+        } catch {
+        }
+      }
+    }
+  };
+}
+function hasLiveTrack(stream, kind) {
+  if (!stream || typeof stream.getTracks !== "function") return false;
+  try {
+    return stream.getTracks().some((track) => track.kind === kind && track.readyState === "live");
+  } catch {
+    return false;
+  }
+}
+function capOf(value) {
+  if (typeof value === "number") return value;
+  if (value && typeof value === "object") {
+    const candidate = value.max ?? value.ideal;
+    if (typeof candidate === "number") return candidate;
+  }
+  return 0;
+}
+function getCaptureLimits({ parameters, kind = "video" }) {
+  const source = parameters || {};
+  if (kind === "screen") {
+    return {
+      width: Number(source.targetWidth) || 0,
+      height: Number(source.targetHeight) || 0,
+      frameRate: Number(source.frameRate) || 30
+    };
+  }
+  const vidCons = source.vidCons || {};
+  return {
+    width: capOf(vidCons.width),
+    height: capOf(vidCons.height),
+    frameRate: Number(source.frameRate) || 0
+  };
+}
+async function enforceCaptureLimits(stream, parameters, kind, allowUnconstrained) {
+  if (kind === "audio") return { ok: true, error: "" };
+  const limits = getCaptureLimits({ parameters, kind });
+  if (!limits.width && !limits.height && !limits.frameRate) return { ok: true, error: "" };
+  let track;
+  try {
+    track = stream.getVideoTracks()[0];
+  } catch {
+    return { ok: true, error: "" };
+  }
+  if (!track) return { ok: true, error: "" };
+  const constraints = {};
+  if (limits.width) constraints.width = { max: limits.width };
+  if (limits.height) constraints.height = { max: limits.height };
+  if (limits.frameRate) constraints.frameRate = { max: limits.frameRate };
+  try {
+    await track.applyConstraints(constraints);
+  } catch {
+  }
+  let settings = {};
+  try {
+    settings = track.getSettings?.() || {};
+  } catch {
+    return { ok: true, error: "" };
+  }
+  if (!settings.width && !settings.height && !settings.frameRate) {
+    return { ok: true, error: "" };
+  }
+  const over = [];
+  if (limits.width && settings.width && settings.width > limits.width) {
+    over.push(`width ${settings.width} > ${limits.width}`);
+  }
+  if (limits.height && settings.height && settings.height > limits.height) {
+    over.push(`height ${settings.height} > ${limits.height}`);
+  }
+  if (limits.frameRate && settings.frameRate && settings.frameRate > limits.frameRate + 1) {
+    over.push(`frameRate ${Math.round(settings.frameRate)} > ${limits.frameRate}`);
+  }
+  if (over.length === 0) return { ok: true, error: "" };
+  if (allowUnconstrained) return { ok: true, error: "" };
+  return {
+    ok: false,
+    error: `This source exceeds the room's capture allowance (${over.join(", ")}). Reduce the source size or frame rate before publishing.`
+  };
+}
+async function produceMedia({
+  parameters,
+  stream,
+  kind,
+  allowUnconstrained = false
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    const readiness = getRoomReadiness({ parameters: live });
+    if (!readiness.ready) return { ok: false, error: readiness.reason };
+    const trackKind = kind === "audio" ? "audio" : "video";
+    if (!hasLiveTrack(stream, trackKind)) {
+      return {
+        ok: false,
+        error: `The stream has no live ${trackKind} track to publish.`
+      };
+    }
+    const limited = await enforceCaptureLimits(stream, live, kind, allowUnconstrained);
+    if (!limited.ok) return limited;
+    if (kind === "audio") {
+      await updateParticipantAudioDecibels.streamSuccessAudio({ stream, parameters: live });
+    } else if (kind === "screen") {
+      await updateParticipantAudioDecibels.streamSuccessScreen({ stream, parameters: live });
+    } else {
+      await updateParticipantAudioDecibels.streamSuccessVideo({ stream, parameters: live });
+    }
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The media could not be published." };
+  }
+}
+async function stopProducing({
+  parameters,
+  kind
+}) {
+  try {
+    const live = getCurrentParams({ parameters });
+    if (kind === "audio") {
+      await updateParticipantAudioDecibels.disconnectSendTransportAudio({ parameters: live });
+    } else if (kind === "screen") {
+      await updateParticipantAudioDecibels.disconnectSendTransportScreen({ parameters: live });
+    } else {
+      await updateParticipantAudioDecibels.disconnectSendTransportVideo({ parameters: live });
+    }
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The producer could not be stopped." };
+  }
+}
+async function produceCanvas({
+  parameters,
+  canvas,
+  frameRate = 30,
+  as = "video"
+}) {
+  try {
+    if (!canvas || typeof canvas.captureStream !== "function") {
+      return {
+        ok: false,
+        error: "This canvas cannot be captured in the current browser.",
+        stream: null
+      };
+    }
+    const stream = canvas.captureStream(frameRate);
+    const result = await produceMedia({ parameters, stream, kind: as });
+    if (!result.ok) {
+      stream.getTracks().forEach((track) => track.stop());
+      return { ...result, stream: null };
+    }
+    return { ...result, stream };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error?.message || "The canvas could not be published.",
+      stream: null
+    };
+  }
+}
+async function produceElement({
+  parameters,
+  element,
+  withVideo,
+  withAudio = true
+}) {
+  try {
+    const capture = element?.captureStream || element?.mozCaptureStream;
+    if (typeof capture !== "function") {
+      return {
+        ok: false,
+        error: "This element cannot be captured in the current browser.",
+        stream: null
+      };
+    }
+    const stream = capture.call(element);
+    const wantsVideo = withVideo ?? hasLiveTrack(stream, "video");
+    const results = [];
+    if (wantsVideo && hasLiveTrack(stream, "video")) {
+      results.push(await produceMedia({ parameters, stream, kind: "video" }));
+    }
+    if (withAudio && hasLiveTrack(stream, "audio")) {
+      results.push(await produceMedia({ parameters, stream, kind: "audio" }));
+    }
+    if (results.length === 0) {
+      return { ok: false, error: "The element has no live tracks yet.", stream: null };
+    }
+    const failure = results.find((result) => !result.ok);
+    if (failure) return { ...failure, stream };
+    return { ok: true, error: "", stream };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error?.message || "The element could not be published.",
+      stream: null
+    };
+  }
+}
+async function produceDisplay({
+  parameters,
+  constraints = { video: true },
+  withAudio = false
+}) {
+  try {
+    const mediaDevices = parameters?.mediaDevices || (typeof navigator !== "undefined" ? navigator.mediaDevices : null);
+    if (!mediaDevices || typeof mediaDevices.getDisplayMedia !== "function") {
+      return {
+        ok: false,
+        error: "Screen capture is unavailable in this browser.",
+        stream: null
+      };
+    }
+    const stream = await mediaDevices.getDisplayMedia({
+      ...constraints,
+      ...withAudio ? { audio: true } : {}
+    });
+    const result = await produceMedia({ parameters, stream, kind: "screen" });
+    if (!result.ok) {
+      stream.getTracks().forEach((track) => track.stop());
+      return { ...result, stream: null };
+    }
+    if (withAudio && hasLiveTrack(stream, "audio")) {
+      await produceMedia({ parameters, stream, kind: "audio" });
+    }
+    return { ...result, stream };
+  } catch (error) {
+    const name = error?.name || "";
+    if (name === "NotAllowedError" || name === "AbortError") {
+      return { ok: false, error: "Screen sharing was cancelled.", stream: null };
+    }
+    return {
+      ok: false,
+      error: error?.message || "The screen could not be shared.",
+      stream: null
+    };
+  }
+}
+async function replaceProducerTrack({
+  parameters,
+  track
+}) {
+  try {
+    if (!track || track.readyState !== "live") {
+      return { ok: false, error: "The replacement track is not live." };
+    }
+    const live = getCurrentParams({ parameters });
+    const producer = track.kind === "audio" ? live.audioProducer || live.localAudioProducer : live.videoProducer || live.localVideoProducer;
+    if (!producer || typeof producer.replaceTrack !== "function") {
+      return {
+        ok: false,
+        error: `There is no live ${track.kind} producer to replace.`
+      };
+    }
+    await producer.replaceTrack({ track });
+    return { ok: true, error: "" };
+  } catch (error) {
+    return { ok: false, error: error?.message || "The track could not be replaced." };
+  }
+}
+async function getParticipantMedia({
+  id = "",
+  name = "",
+  kind = "video",
+  parameters
+}) {
+  try {
+    if (!parameters) return null;
+    const live = typeof parameters.getCurrentParams === "function" ? parameters.getCurrentParams() || parameters : parameters;
+    const participants = Array.isArray(live.participants) ? live.participants : [];
+    const streams = Array.isArray(
+      kind === "video" ? live.allVideoStreams : live.allAudioStreams
+    ) ? kind === "video" ? live.allVideoStreams : live.allAudioStreams : [];
+    if (streams.length === 0) return null;
+    let participant = id ? participants.find((part) => part.id === id) : void 0;
+    if (!participant && name) {
+      participant = participants.find((part) => part.name === name);
+    }
+    const producerId = participant ? kind === "video" ? participant.videoID : participant.audioID : "";
+    if (producerId) {
+      const match = streams.find((stream) => stream.producerId === producerId);
+      if (match && match.stream) return match.stream;
+    }
+    if (id) {
+      const direct = streams.find((stream) => stream.producerId === id);
+      if (direct && direct.stream) return direct.stream;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+exports.assignParticipantToBreakoutRoom = assignParticipantToBreakoutRoom;
+exports.attachPlayback = attachPlayback;
+exports.checkPauseState = checkPauseState;
+exports.checkResumeState = checkResumeState;
+exports.confirmExit = confirmExit;
+exports.confirmRecording = confirmRecording;
+exports.confirmStillHere = confirmStillHere;
+exports.createRoomPoll = createRoomPoll;
+exports.createViewerSession = createViewerSession;
+exports.detachPlayback = detachPlayback;
+exports.disableParticipantVideo = disableParticipantVideo;
+exports.endRoomPoll = endRoomPoll;
+exports.flipCamera = flipCamera;
+exports.getActiveSpeaker = getActiveSpeaker;
+exports.getAudioGridComponents = getAudioGridComponents;
+exports.getBreakoutState = getBreakoutState;
+exports.getCaptureLimits = getCaptureLimits;
+exports.getChatMessages = getChatMessages;
+exports.getCurrentParams = getCurrentParams;
+exports.getFocusModeState = getFocusModeState;
+exports.getLocalAudioStream = getLocalAudioStream;
+exports.getLocalVideoStream = getLocalVideoStream;
+exports.getLocallyPausedProducerIds = getLocallyPausedProducerIds;
+exports.getMediaPermissions = getMediaPermissions;
+exports.getModalPosition = getModalPosition;
+exports.getModerationPermissions = getModerationPermissions;
+exports.getParticipantMedia = getParticipantMedia;
+exports.getParticipantMediaState = getParticipantMediaState;
+exports.getPendingApprovals = getPendingApprovals;
+exports.getPlaybackSources = getPlaybackSources;
+exports.getPollState = getPollState;
+exports.getPresenceCheck = getPresenceCheck;
+exports.getRecordingCapabilities = getRecordingCapabilities;
+exports.getRecordingNotice = getRecordingNotice;
+exports.getRecordingState = getRecordingState;
+exports.getRemoteAudioStreams = getRemoteAudioStreams;
+exports.getRemoteVideoStreams = getRemoteVideoStreams;
+exports.getRoomReadiness = getRoomReadiness;
+exports.getScreenShareStream = getScreenShareStream;
+exports.getSelectedDevices = getSelectedDevices;
+exports.getSessionTimer = getSessionTimer;
+exports.getTranslationState = getTranslationState;
+exports.getVirtualBackgroundState = getVirtualBackgroundState;
+exports.getWhiteboardState = getWhiteboardState;
+exports.handleCreatePoll = handleCreatePoll;
+exports.handleEndPoll = handleEndPoll;
+exports.handleStartBreakout = handleStartBreakout;
+exports.handleStartWhiteboard = handleStartWhiteboard;
+exports.handleStopBreakout = handleStopBreakout;
+exports.handleStopWhiteboard = handleStopWhiteboard;
+exports.handleVotePoll = handleVotePoll;
+exports.launchBackground = launchBackground;
+exports.launchBreakoutRooms = launchBreakoutRooms;
+exports.launchCoHost = launchCoHost;
+exports.launchConfigureWhiteboard = launchConfigureWhiteboard;
+exports.launchConfirmExit = launchConfirmExit;
+exports.launchDisplaySettings = launchDisplaySettings;
+exports.launchMediaSettings = launchMediaSettings;
+exports.launchMenuModal = launchMenuModal;
+exports.launchMessages = launchMessages;
+exports.launchParticipants = launchParticipants;
+exports.launchPoll = launchPoll;
+exports.launchRecording = launchRecording;
+exports.launchRequests = launchRequests;
+exports.launchSettings = launchSettings;
+exports.launchWaiting = launchWaiting;
+exports.leaveRoom = leaveRoom;
+exports.listMediaDevices = listMediaDevices;
+exports.listParticipantMediaStates = listParticipantMediaStates;
+exports.messageParticipants = messageParticipants;
+exports.modifyCoHostSettings = modifyCoHostSettings;
+exports.modifyDisplaySettings = modifyDisplaySettings;
+exports.muteEveryone = muteEveryone;
+exports.muteParticipant = muteParticipant;
+exports.muteParticipants = muteParticipants;
+exports.pauseRoomRecording = pauseRoomRecording;
+exports.produceCanvas = produceCanvas;
+exports.produceDisplay = produceDisplay;
+exports.produceElement = produceElement;
+exports.produceMedia = produceMedia;
+exports.publishWhip = publishWhip;
+exports.reapplyLocalPlayback = reapplyLocalPlayback;
+exports.recordPauseTimer = recordPauseTimer;
+exports.recordResumeTimer = recordResumeTimer;
+exports.recordStartTimer = recordStartTimer;
+exports.recordUpdateTimer = recordUpdateTimer;
+exports.removeParticipant = removeParticipant;
+exports.removeParticipants = removeParticipants;
+exports.replaceProducerTrack = replaceProducerTrack;
+exports.respondToParticipantRequest = respondToParticipantRequest;
+exports.respondToRequests = respondToRequests;
+exports.respondToWaiting = respondToWaiting;
+exports.respondToWaitingParticipant = respondToWaitingParticipant;
+exports.resumeRoomRecording = resumeRoomRecording;
+exports.runMediaControl = runMediaControl;
+exports.sendChatMessage = sendChatMessage;
+exports.sendMessage = sendMessage;
+exports.setBreakoutRooms = setBreakoutRooms;
+exports.setCoHost = setCoHost;
+exports.setParticipantMedia = setParticipantMedia;
+exports.setParticipantPlayback = setParticipantPlayback;
+exports.setRoomMediaPolicy = setRoomMediaPolicy;
+exports.setTranslationPreference = setTranslationPreference;
+exports.startRecording = startRecording;
+exports.startRoomRecording = startRoomRecording;
+exports.startWhiteboard = startWhiteboard;
+exports.stopBreakoutRooms = stopBreakoutRooms;
+exports.stopParticipantScreenShare = stopParticipantScreenShare;
+exports.stopProducing = stopProducing;
+exports.stopRecording = stopRecording;
+exports.stopRoomRecording = stopRoomRecording;
+exports.stopWhiteboard = stopWhiteboard;
+exports.switchAudio = switchAudio;
+exports.switchCamera = switchCamera;
+exports.switchMicrophone = switchMicrophone;
+exports.switchVideo = switchVideo;
+exports.switchVideoAlt = switchVideoAlt;
+exports.updateRecording = updateRecording;
+exports.voteInRoomPoll = voteInRoomPoll;
+//# sourceMappingURL=getParticipantMedia-CdcYqcbD.cjs.map