@arbidocs/react 0.5.111 → 0.5.113

package/dist/calls/livekit/index.js

@@ -1,959 +1,7 @@
-import { toProfileView, useCallTranscriptionAvailable, onCallEvent, transcriptPersistRole, persistTranscriptSegment, newSegmentId, encodeCaptionPacket, CALL_CAPTION_TOPIC, ensureMeetingChat, trackUploaderFor, conversationKeyForCall, loadMeetingHistory, CALL_CHAT_MAX_CHARS, newPacketId, encodeCallChatPacket, CALL_CHAT_TOPIC, persistMeetingMessage, mergeChatLines, openQuestion, markRejoining, sealQuestionText, createMutedNotifier, CALL_RECORDING_TOPIC, CALL_TRANSCRIPTION_TOPIC, decodeCaptionPacket, CALL_MODERATION_TOPIC, mutedNoticeFromPacket, decodeCallChatPacket, CALL_WEBINAR_TOPIC, parseWebinarPacket } from '../../chunk-DZKRL5H3.js';
-import '../../chunk-4FL3X3LA.js';
-import { useArbi, useArbiHost } from '../../chunk-ZM6N7YZH.js';
-import { notify } from '../../chunk-BF5KW5ZI.js';
-import '../../chunk-DPYBZDJB.js';
-import '../../chunk-UW2SGTI5.js';
-import '../../chunk-WUTL62MC.js';
-import '../../chunk-APZZQZ6P.js';
-import '../../chunk-VSCU7K4V.js';
-import '../../chunk-SN5YV6FF.js';
-import { useState, useEffect, useRef, useCallback, useMemo } from 'react';
-import { RoomEvent, ExternalE2EEKeyProvider, Room } from 'livekit-client';
-import { useRoomContext, useLocalParticipant, useLocalParticipantPermissions } from '@livekit/components-react';
-import { useQueryClient } from '@tanstack/react-query';
-import { calls, continuityPrompt, CallApiError } from '@arbidocs/sdk/browser';
-
-function createE2EEWorker() {
-  return new Worker(new URL("livekit-client/e2ee-worker", import.meta.url), { type: "module" });
-}
-function createRoom(e2eeKey, choices, createWorker) {
-  const options = {
-    adaptiveStream: true,
-    dynacast: true,
-    audioCaptureDefaults: choices.audioDeviceId ? { deviceId: choices.audioDeviceId } : void 0,
-    videoCaptureDefaults: choices.videoDeviceId ? { deviceId: choices.videoDeviceId } : void 0
-  };
-  let worker = null;
-  let keyProvider = null;
-  if (e2eeKey) {
-    keyProvider = new ExternalE2EEKeyProvider();
-    worker = createWorker();
-    options.e2ee = { keyProvider, worker };
-  }
-  const room = new Room(options);
-  const ready = (async () => {
-    if (!keyProvider || !e2eeKey) return;
-    await keyProvider.setKey(e2eeKey.slice().buffer);
-    await room.setE2EEEnabled(true);
-  })();
-  return { bundle: { room, worker }, ready };
-}
-function useCallRoom(e2eeKey, choices, options = {}) {
-  const [room, setRoom] = useState(null);
-  const [error, setError] = useState(null);
-  useEffect(() => {
-    let cancelled = false;
-    let created = null;
-    try {
-      const { bundle, ready } = createRoom(
-        e2eeKey,
-        choices,
-        options.createWorker ?? createE2EEWorker
-      );
-      created = bundle;
-      ready.then(() => {
-        if (!cancelled) setRoom(bundle.room);
-      }).catch((err) => {
-        console.error("[calls] E2EE setup failed", err);
-        if (!cancelled) setError("This browser cannot encrypt the call (E2EE unsupported).");
-      });
-    } catch (err) {
-      console.error("[calls] room setup failed", err);
-      setError("Could not set up the call in this browser.");
-    }
-    return () => {
-      cancelled = true;
-      if (created) {
-        void created.room.disconnect();
-        created.worker?.terminate();
-      }
-      setRoom(null);
-    };
-  }, [e2eeKey]);
-  return { room, error };
-}
-var MUTE_REQUEST_TOPIC = "arbi.mute-request";
-function useMuteRequests() {
-  const room = useRoomContext();
-  useEffect(() => {
-    const onData = (payload, from, _kind, topic) => {
-      if (topic !== MUTE_REQUEST_TOPIC || !from) return;
-      const who = from.name || from.identity;
-      notify.info(`${who} asks you to mute your microphone`, {
-        action: {
-          label: "Mute",
-          onClick: () => void room.localParticipant.setMicrophoneEnabled(false)
-        }
-      });
-    };
-    room.on(RoomEvent.DataReceived, onData);
-    return () => {
-      room.off(RoomEvent.DataReceived, onData);
-    };
-  }, [room]);
-  return (identity) => void room.localParticipant.publishData(new TextEncoder().encode('{"v":1}'), {
-    reliable: true,
-    topic: MUTE_REQUEST_TOPIC,
-    destinationIdentities: [identity]
-  }).then(() => notify.info("Asked to mute")).catch((err) => notify.error(`Could not ask: ${err.message}`));
-}
-var FINAL_SEGMENT_GRACE_MS = 3e4;
-function mayStillSend(params) {
-  if (params.sending) return true;
-  if (params.stoppedAt === null) return false;
-  return params.segmentStartedAt <= params.stoppedAt && params.now - params.stoppedAt <= FINAL_SEGMENT_GRACE_MS;
-}
-function storedSpeakerName(participantName, profileName, identity) {
-  return participantName?.trim() || profileName?.trim() || identity;
-}
-function useCallTranscriber({
-  callExtId,
-  callKey,
-  isCreator,
-  canPost,
-  linkVersion = null
-}) {
-  const room = useRoomContext();
-  const { localParticipant } = useLocalParticipant();
-  const myIdentity = localParticipant.identity;
-  const arbi = useArbi();
-  const queryClient = useQueryClient();
-  const profile = arbi.isLoggedIn ? arbi.user.profile() : null;
-  const myProfileName = profile && toProfileView(profile).fullName || null;
-  const deploymentAvailable = useCallTranscriptionAvailable();
-  const available = deploymentAvailable && !!callKey;
-  const [state, setState] = useState(null);
-  const [creatorExtId, setCreatorExtId] = useState(null);
-  const [busy, setBusy] = useState(false);
-  const [muted, setMuted] = useState(false);
-  const [indicatorShown, setIndicatorShown] = useState(false);
-  const [captions, setCaptions] = useState([]);
-  const liveUpdate = useRef(false);
-  const persisted = useRef(/* @__PURE__ */ new Set());
-  const saveFailureShown = useRef(false);
-  const selfPosts = useRef(canPost);
-  useEffect(() => {
-    selfPosts.current = canPost;
-  }, [canPost]);
-  const on = available && !!state?.on;
-  const shouldSend = on && indicatorShown && !muted;
-  const shouldSendRef = useRef(shouldSend);
-  const sendStoppedAtRef = useRef(null);
-  if (shouldSendRef.current !== shouldSend) {
-    sendStoppedAtRef.current = shouldSend ? null : Date.now();
-  }
-  shouldSendRef.current = shouldSend;
-  const myPreviousText = useRef("");
-  const applyState = useCallback((next) => {
-    liveUpdate.current = true;
-    setState(next);
-  }, []);
-  useEffect(() => {
-    if (!available) return;
-    let cancelled = false;
-    arbi.calls.get(callExtId).then((call) => {
-      if (cancelled) return;
-      setCreatorExtId(call.creator_ext_id ?? null);
-      if (!liveUpdate.current) {
-        setState(calls.transcriptionStateFrom(call.transcription));
-      }
-    }).catch((err) => console.warn("[calls] could not read the transcription state", err));
-    return () => {
-      cancelled = true;
-    };
-  }, [available, callExtId]);
-  useEffect(
-    () => onCallEvent("call.transcription", (message) => {
-      if (message.call_ext_id === callExtId) applyState(message);
-    }),
-    [callExtId, applyState]
-  );
-  const addCaption = useCallback((line) => {
-    setCaptions((prev) => {
-      if (prev.some((c) => c.segmentId === line.segmentId && c.identity === line.identity)) {
-        return prev;
-      }
-      return [...prev, line].sort((a, b) => a.t - b.t).slice(-30);
-    });
-  }, []);
-  const persist = useCallback(
-    (segment, speakerNeedsProxy) => {
-      if (!callKey || persisted.current.has(segment.segmentId)) return;
-      const role = transcriptPersistRole({
-        myIdentity,
-        canPost: canPost && (segment.speakerIdentity !== myIdentity || selfPosts.current),
-        hasCallKey: true,
-        speakerIdentity: segment.speakerIdentity,
-        speakerNeedsProxy
-      });
-      if (!role) return;
-      persisted.current.add(segment.segmentId);
-      persistTranscriptSegment(arbi, queryClient, callExtId, callKey, segment).catch(
-        (err) => {
-          persisted.current.delete(segment.segmentId);
-          if (role === "own" && err?.status === 403) {
-            selfPosts.current = false;
-          }
-          console.warn("[calls] could not keep the transcript line", err);
-          if (!saveFailureShown.current) {
-            saveFailureShown.current = true;
-            notify.warning(
-              `Transcript lines are not being saved to the meeting chat: ${err?.message ?? "unknown error"}`
-            );
-          }
-        }
-      );
-    },
-    [callExtId, callKey, myIdentity, canPost]
-  );
-  useEffect(() => {
-    const onData = (payload, participant, _kind, topic, _encryption, participantIdentity) => {
-      if (topic === CALL_TRANSCRIPTION_TOPIC) {
-        if (participant || participantIdentity) return;
-        try {
-          const next = calls.transcriptionStateFrom(JSON.parse(new TextDecoder().decode(payload)));
-          if (next) applyState(next);
-        } catch {
-        }
-        return;
-      }
-      if (topic !== CALL_CAPTION_TOPIC || !callKey) return;
-      const identity = participant?.identity ?? participantIdentity;
-      if (!identity || identity === myIdentity) return;
-      void decodeCaptionPacket(payload, callKey).then((packet) => {
-        if (!packet || packet.identity !== identity) return;
-        const name = participant?.name || packet.name || identity;
-        const t = Math.min(packet.t, Date.now());
-        addCaption({
-          segmentId: packet.segment_id,
-          identity,
-          name,
-          text: packet.text,
-          t,
-          mine: false,
-          receivedAt: Date.now()
-        });
-        persist(
-          {
-            segmentId: packet.segment_id,
-            text: packet.text,
-            speakerIdentity: identity,
-            speakerName: name,
-            startedAt: new Date(t).toISOString()
-          },
-          packet.proxy === true
-        );
-      });
-    };
-    room.on(RoomEvent.DataReceived, onData);
-    return () => {
-      room.off(RoomEvent.DataReceived, onData);
-    };
-  }, [room, callKey, myIdentity, addCaption, applyState, persist]);
-  const handleSegment = useCallback(
-    async (segment) => {
-      if (!callKey || !mayStillSend({
-        sending: shouldSendRef.current,
-        stoppedAt: sendStoppedAtRef.current,
-        segmentStartedAt: segment.startedAt,
-        now: Date.now()
-      })) {
-        return;
-      }
-      const segmentId = newSegmentId();
-      const startedAt = new Date(segment.startedAt).toISOString();
-      let text;
-      try {
-        const result = await arbi.calls.transcription.transcribe(callExtId, {
-          audio: segment.blob,
-          segmentId,
-          startedAt,
-          linkVersion,
-          prompt: continuityPrompt(myPreviousText.current)
-        });
-        text = result.text.trim();
-      } catch (err) {
-        if (err instanceof CallApiError && err.status === 409) {
-          applyState({ on: false, by_identity: null, by_name: null });
-        }
-        console.warn("[calls] could not transcribe a segment", err);
-        return;
-      }
-      if (!text) return;
-      myPreviousText.current = `${myPreviousText.current} ${text}`.slice(-400);
-      const name = storedSpeakerName(localParticipant.name, myProfileName, myIdentity);
-      const proxy = !selfPosts.current;
-      addCaption({
-        segmentId,
-        identity: myIdentity,
-        name,
-        text,
-        t: segment.startedAt,
-        mine: true,
-        receivedAt: Date.now()
-      });
-      try {
-        await localParticipant.publishData(
-          await encodeCaptionPacket(
-            {
-              v: 1,
-              segment_id: segmentId,
-              text,
-              identity: myIdentity,
-              name,
-              t: segment.startedAt,
-              ...proxy ? { proxy: true } : {}
-            },
-            callKey
-          ),
-          { reliable: true, topic: CALL_CAPTION_TOPIC }
-        );
-      } catch (err) {
-        console.warn("[calls] could not broadcast a caption", err);
-      }
-      if (!proxy) {
-        persist(
-          { segmentId, text, speakerIdentity: myIdentity, speakerName: name, startedAt },
-          false
-        );
-      }
-    },
-    [
-      callExtId,
-      callKey,
-      linkVersion,
-      localParticipant,
-      myIdentity,
-      myProfileName,
-      addCaption,
-      applyState,
-      persist
-    ]
-  );
-  const startedByMe = !!state?.on && state.by_identity === myIdentity;
-  const canToggle = available && (isCreator || !!creatorExtId && creatorExtId === myIdentity);
-  const toggle = useCallback(async () => {
-    if (!canToggle) return;
-    const next = !on;
-    setBusy(true);
-    try {
-      const answer = await arbi.calls.transcription.set(callExtId, next);
-      applyState(
-        answer ?? (next ? { on: true, by_identity: myIdentity, by_name: localParticipant.name || null } : { on: false, by_identity: null, by_name: null })
-      );
-    } catch (err) {
-      notify.error(`Could not turn transcription ${next ? "on" : "off"}: ${err.message}`);
-    } finally {
-      setBusy(false);
-    }
-  }, [on, canToggle, callExtId, myIdentity, localParticipant, applyState]);
-  return useMemo(
-    () => ({
-      available,
-      on,
-      startedByName: on ? state?.by_name ?? null : null,
-      startedByMe,
-      canToggle,
-      busy,
-      muted,
-      setMuted,
-      toggle,
-      setIndicatorShown,
-      shouldSend,
-      captions,
-      handleSegment
-    }),
-    [
-      available,
-      on,
-      state,
-      startedByMe,
-      canToggle,
-      busy,
-      muted,
-      toggle,
-      shouldSend,
-      captions,
-      handleSegment
-    ]
-  );
-}
-function captureAllowed(params) {
-  return params.available && !!params.state?.on && !!params.state.recording_ext_id && params.indicatorShown;
-}
-function useCallRecorder({
-  callExtId,
-  callKey,
-  isCreator,
-  linkVersion = null
-}) {
-  const arbi = useArbi();
-  const queryClient = useQueryClient();
-  const room = useRoomContext();
-  const { localParticipant } = useLocalParticipant();
-  const myIdentity = localParticipant.identity;
-  const available = !!callKey;
-  const [state, setState] = useState(null);
-  const [call, setCall] = useState(null);
-  const [busy, setBusy] = useState(false);
-  const [indicatorShown, setIndicatorShown] = useState(false);
-  const [pendingStart, setPendingStart] = useState(null);
-  const liveUpdate = useRef(false);
-  const stateRef = useRef(null);
-  stateRef.current = state;
-  const applyState = useCallback((next) => {
-    liveUpdate.current = true;
-    if (stateRef.current?.on && next && !next.on && next.reason === "storage_quota_exceeded") {
-      notify.warning("Recording stopped: the storage is full.");
-    }
-    stateRef.current = next;
-    setState(next);
-  }, []);
-  useEffect(() => {
-    let cancelled = false;
-    arbi.calls.get(callExtId).then((row) => {
-      if (cancelled) return;
-      setCall(row);
-      if (!liveUpdate.current) setState(calls.recordingStateOfCall(row));
-    }).catch((err) => console.warn("[calls] could not read the recording state", err));
-    return () => {
-      cancelled = true;
-    };
-  }, [callExtId]);
-  useEffect(
-    () => onCallEvent("call.recording", (message) => {
-      if (message.call_ext_id === callExtId) applyState(message);
-    }),
-    [callExtId, applyState]
-  );
-  useEffect(() => {
-    const onData = (payload, participant, _kind, topic, _encryption, participantIdentity) => {
-      if (topic !== CALL_RECORDING_TOPIC) return;
-      if (participant || participantIdentity) return;
-      try {
-        const next = calls.recordingStateFrom(JSON.parse(new TextDecoder().decode(payload)));
-        if (next) applyState(next);
-      } catch {
-      }
-    };
-    room.on(RoomEvent.DataReceived, onData);
-    return () => {
-      room.off(RoomEvent.DataReceived, onData);
-    };
-  }, [room, applyState]);
-  const canControl = available && (isCreator || !!call && call.creator_ext_id === myIdentity);
-  const on = !!state?.on;
-  const start = useCallback(
-    async (mode) => {
-      setBusy(true);
-      try {
-        const row = call ?? await arbi.calls.get(callExtId);
-        if (!row.workspace_locked && !row.chat_ext_id && callKey) {
-          const ref = await ensureMeetingChat(arbi, queryClient, callExtId, callKey);
-          if (ref.kind === "chat") setCall({ ...row, chat_ext_id: ref.chatExtId });
-        }
-        const answer = await arbi.calls.recording.start(callExtId, mode);
-        if (answer) applyState(answer);
-      } catch (err) {
-        notify.error(`Could not start recording: ${err.message}`);
-      } finally {
-        setBusy(false);
-      }
-    },
-    [callExtId, callKey, call, applyState]
-  );
-  const requestStart = useCallback(
-    async (mode) => {
-      if (!canControl || on) return;
-      setBusy(true);
-      let quota = null;
-      try {
-        quota = await arbi.calls.recording.quota(callExtId);
-      } catch (err) {
-        console.warn("[calls] could not read the recording quota", err);
-      }
-      setBusy(false);
-      if (quota && calls.quotaNeedsWarning(quota)) {
-        setPendingStart({ mode, quota });
-        return;
-      }
-      await start(mode);
-    },
-    [canControl, on, callExtId, start]
-  );
-  const confirmStart = useCallback(async () => {
-    const pending = pendingStart;
-    setPendingStart(null);
-    if (pending) await start(pending.mode);
-  }, [pendingStart, start]);
-  const cancelStart = useCallback(() => setPendingStart(null), []);
-  const stop = useCallback(async () => {
-    if (!canControl || !on) return;
-    setBusy(true);
-    try {
-      const answer = await arbi.calls.recording.stop(callExtId);
-      applyState(answer ?? { ...state, on: false });
-    } catch (err) {
-      notify.error(`Could not stop recording: ${err.message}`);
-    } finally {
-      setBusy(false);
-    }
-  }, [canControl, on, callExtId, state, applyState]);
-  const markStopped = useCallback(() => {
-    const prev = stateRef.current;
-    if (prev?.on) applyState({ ...prev, on: false, reason: "storage_quota_exceeded" });
-  }, [applyState]);
-  const shouldCapture = captureAllowed({ available, state, indicatorShown });
-  return useMemo(
-    () => ({
-      available,
-      on,
-      mode: on ? state?.mode ?? "audio" : null,
-      recordingExtId: state?.recording_ext_id ?? null,
-      startedAt: state?.started_at ?? null,
-      startedByName: on ? state?.by_name ?? null : null,
-      startedByMe: on && state?.by_identity === myIdentity,
-      canControl,
-      busy,
-      call,
-      linkVersion,
-      requestStart,
-      pendingStart,
-      confirmStart,
-      cancelStart,
-      stop,
-      setIndicatorShown,
-      shouldCapture,
-      markStopped
-    }),
-    [
-      available,
-      on,
-      state,
-      myIdentity,
-      canControl,
-      busy,
-      call,
-      linkVersion,
-      requestStart,
-      pendingStart,
-      confirmStart,
-      cancelStart,
-      stop,
-      shouldCapture,
-      markStopped
-    ]
-  );
-}
-function useTrackUploader(recording, callKey, kind, mimeType) {
-  const { recordingExtId, call, startedAt, shouldCapture, markStopped, linkVersion } = recording;
-  const arbi = useArbi();
-  const queryClient = useQueryClient();
-  return useMemo(() => {
-    if (!shouldCapture || !recordingExtId || !call) return null;
-    return trackUploaderFor({
-      arbi,
-      callExtId: call.external_id,
-      recordingExtId,
-      kind,
-      mimeType,
-      recordingStartedAt: startedAt,
-      linkVersion,
-      conversationKey: () => conversationKeyForCall(arbi, queryClient, call, { callKey }),
-      // The server stopped the recording at the quota (its state event says so too).
-      onStopped: () => markStopped()
-    });
-  }, [
-    arbi,
-    queryClient,
-    shouldCapture,
-    recordingExtId,
-    call,
-    startedAt,
-    linkVersion,
-    kind,
-    mimeType,
-    callKey,
-    markStopped
-  ]);
-}
-function useInCallChat({
-  callExtId,
-  callKey,
-  open,
-  readOnly = false,
-  persist = true
-}) {
-  const room = useRoomContext();
-  const { localParticipant } = useLocalParticipant();
-  const myIdentity = localParticipant.identity;
-  const arbi = useArbi();
-  const queryClient = useQueryClient();
-  const openMeetingChat = useArbiHost().calls?.openMeetingChat;
-  const signedIn = arbi.isLoggedIn;
-  const persists = !!callKey && signedIn && !readOnly && persist;
-  const [live, setLive] = useState([]);
-  const [history, setHistory] = useState([]);
-  const [historyLoading, setHistoryLoading] = useState(false);
-  const [historyError, setHistoryError] = useState(null);
-  const [meetingChat, setMeetingChat] = useState(null);
-  const [unread, setUnread] = useState(0);
-  const openRef = useRef(open);
-  openRef.current = open;
-  const historyRequested = useRef(false);
-  const seen = useRef(/* @__PURE__ */ new Set());
-  useEffect(() => {
-    if (open) setUnread(0);
-  }, [open]);
-  useEffect(() => {
-    if (!callKey) return;
-    const onData = (payload, participant, _kind, topic, _encryption, participantIdentity) => {
-      if (topic !== CALL_CHAT_TOPIC) return;
-      const identity = participant?.identity ?? participantIdentity;
-      if (!identity || identity === myIdentity) return;
-      void decodeCallChatPacket(payload, callKey).then((packet) => {
-        if (!packet) return;
-        const key = `${identity}:${packet.id}`;
-        if (seen.current.has(key)) return;
-        seen.current.add(key);
-        setLive((prev) => [
-          ...prev,
-          {
-            id: packet.id,
-            senderIdentity: identity,
-            senderName: participant?.name || identity,
-            text: packet.text,
-            at: Math.min(packet.at, Date.now()),
-            mine: false,
-            status: "live"
-          }
-        ]);
-        if (!openRef.current) setUnread((n) => n + 1);
-      });
-    };
-    room.on(RoomEvent.DataReceived, onData);
-    return () => {
-      room.off(RoomEvent.DataReceived, onData);
-    };
-  }, [room, callKey, myIdentity]);
-  const canRead = !!callKey && signedIn && persist;
-  useEffect(() => {
-    if (!open || !canRead || historyRequested.current) return;
-    historyRequested.current = true;
-    setHistoryLoading(true);
-    loadMeetingHistory(arbi, queryClient, callExtId).then((result) => {
-      if (!result) return;
-      setMeetingChat(result.ref);
-      setHistory(result.messages);
-    }).catch((err) => {
-      console.warn("[calls] could not load the meeting chat", err);
-      setHistoryError("Earlier messages could not be loaded.");
-    }).finally(() => setHistoryLoading(false));
-  }, [open, canRead, callExtId]);
-  const send = useCallback(
-    async (raw) => {
-      const text = raw.trim().slice(0, CALL_CHAT_MAX_CHARS);
-      if (!text || !callKey || readOnly) return;
-      const id = newPacketId();
-      const at = Date.now();
-      await localParticipant.publishData(
-        await encodeCallChatPacket({ v: 1, id, text, at }, callKey),
-        { reliable: true, topic: CALL_CHAT_TOPIC }
-      );
-      setLive((prev) => [
-        ...prev,
-        {
-          id,
-          senderIdentity: myIdentity,
-          senderName: localParticipant.name || "You",
-          text,
-          at,
-          mine: true,
-          status: persists ? "saving" : "live"
-        }
-      ]);
-      if (!persists) return;
-      const mark = (status) => setLive(
-        (prev) => prev.map((l) => l.id === id && l.senderIdentity === myIdentity ? { ...l, status } : l)
-      );
-      try {
-        setMeetingChat(await persistMeetingMessage(arbi, queryClient, callExtId, callKey, text));
-        mark("saved");
-      } catch (err) {
-        console.warn("[calls] could not keep the message in the meeting chat", err);
-        mark("unsaved");
-      }
-    },
-    [callKey, callExtId, localParticipant, myIdentity, persists, readOnly]
-  );
-  const openMeeting = useCallback(async () => {
-    if (!callKey) return;
-    try {
-      const ref = meetingChat ?? await ensureMeetingChat(arbi, queryClient, callExtId, callKey);
-      setMeetingChat(ref);
-      openMeetingChat?.(ref);
-    } catch (err) {
-      notify.error(`Could not open the meeting chat: ${err.message}`);
-    }
-  }, [callExtId, callKey, meetingChat]);
-  const lines = useMemo(
-    () => mergeChatLines(history, live, {
-      myIdentity,
-      nameOf: (identity) => identity === myIdentity ? localParticipant.name || "You" : room.remoteParticipants.get(identity)?.name || null
-    }),
-    [history, live, myIdentity, localParticipant, room]
-  );
-  return {
-    lines,
-    unread,
-    available: !!callKey,
-    persists,
-    readOnly,
-    historyLoading,
-    historyError,
-    meetingChat,
-    send,
-    openMeeting
-  };
-}
-var DEMOTE_REJOIN_FALLBACK_MS = 5e3;
-function failed(what) {
-  return (err) => {
-    notify.error(`Could not ${what}: ${err?.message ?? "unknown error"}`);
-    throw err;
-  };
-}
-function useWebinar({
-  role: roleHint = null,
-  callExtId,
-  linkVersion = null,
-  callKey
-}) {
-  const arbi = useArbi();
-  const webinarApi = useCallback(() => arbi.calls.webinar, [arbi]);
-  const enabled = !!roleHint;
-  const room = useRoomContext();
-  const { localParticipant } = useLocalParticipant();
-  const myIdentity = localParticipant.identity;
-  const permissions = useLocalParticipantPermissions();
-  const [state, setState] = useState(null);
-  const [questions, setQuestions] = useState([]);
-  const [stageCheck, setStageCheck] = useState(false);
-  const stateRead = useRef(0);
-  const questionsRead = useRef(0);
-  const refresh = useCallback(async () => {
-    if (!enabled) return;
-    const n = ++stateRead.current;
-    try {
-      const next = await webinarApi().get(callExtId, linkVersion);
-      if (n === stateRead.current) setState(next);
-    } catch (err) {
-      console.warn("[calls] could not read the webinar state", err);
-    }
-  }, [enabled, callExtId, linkVersion]);
-  const refreshQuestions = useCallback(async () => {
-    if (!enabled || !callKey) return;
-    const n = ++questionsRead.current;
-    try {
-      const rows = await webinarApi().questions.list(callExtId, linkVersion);
-      const opened = await Promise.all(rows.map((q) => openQuestion(q, callKey)));
-      if (n === questionsRead.current) setQuestions(opened);
-    } catch (err) {
-      console.warn("[calls] could not load the questions", err);
-    }
-  }, [enabled, callExtId, linkVersion, callKey]);
-  useEffect(() => {
-    void refresh();
-    void refreshQuestions();
-  }, [refresh, refreshQuestions]);
-  useEffect(() => {
-    if (!enabled) return;
-    return onCallEvent("call.webinar", (m) => {
-      if (m.call_ext_id !== callExtId) return;
-      setState((s) => s ? { ...s, live: m.live, chat: m.chat } : s);
-    });
-  }, [enabled, callExtId]);
-  const fallback = useRef(null);
-  useEffect(() => {
-    if (!enabled) return;
-    const onData = (payload, participant, _kind, topic, _encryption, participantIdentity) => {
-      if (topic !== CALL_WEBINAR_TOPIC) return;
-      const packet = parseWebinarPacket(payload, !!(participant || participantIdentity));
-      if (!packet) return;
-      switch (packet.type) {
-        case "state":
-          setState(
-            (s) => s ? { ...s, live: packet.live, live_at: packet.live_at, chat: packet.chat } : s
-          );
-          void refresh();
-          return;
-        case "hands":
-          setState((s) => s ? { ...s, hands: packet.hands } : s);
-          return;
-        case "questions":
-          void refreshQuestions();
-          return;
-        case "promoted":
-          setStageCheck(true);
-          void refresh();
-          return;
-        case "demoted":
-          setStageCheck(false);
-          markRejoining(callExtId);
-          if (fallback.current) clearTimeout(fallback.current);
-          fallback.current = setTimeout(() => void room.disconnect(), DEMOTE_REJOIN_FALLBACK_MS);
-          return;
-      }
-    };
-    room.on(RoomEvent.DataReceived, onData);
-    return () => {
-      room.off(RoomEvent.DataReceived, onData);
-    };
-  }, [enabled, room, callExtId, refresh, refreshQuestions]);
-  useEffect(
-    () => () => {
-      if (fallback.current) clearTimeout(fallback.current);
-    },
-    []
-  );
-  const role = enabled ? state?.my_role ?? null : null;
-  const onStage = !enabled || (permissions ? permissions.canPublish : state ? state.on_stage : roleHint !== "attendee");
-  const patch = useCallback(
-    async (body, what) => {
-      const next = await webinarApi().update(callExtId, body, linkVersion).catch(failed(what));
-      setState(next);
-    },
-    [callExtId, linkVersion]
-  );
-  const stepDown = useCallback(async () => {
-    markRejoining(callExtId);
-    setStageCheck(false);
-    try {
-      await webinarApi().demote(callExtId, myIdentity, linkVersion);
-    } catch (err) {
-      markRejoining(callExtId, false);
-      failed("leave the stage")(err);
-    }
-  }, [callExtId, myIdentity, linkVersion]);
-  const joinStage = useCallback(
-    async (choices) => {
-      const lp = room.localParticipant;
-      try {
-        await lp.setMicrophoneEnabled(
-          choices.audioEnabled,
-          choices.audioDeviceId ? { deviceId: choices.audioDeviceId } : void 0
-        );
-        await lp.setCameraEnabled(
-          choices.videoEnabled,
-          choices.videoDeviceId ? { deviceId: choices.videoDeviceId } : void 0
-        );
-      } catch (err) {
-        failed("turn on your microphone or camera")(err);
-      }
-      setStageCheck(false);
-    },
-    [room]
-  );
-  const questionAction = useCallback(
-    async (run, what) => {
-      await run().catch(failed(what));
-      void refreshQuestions();
-    },
-    [refreshQuestions]
-  );
-  return useMemo(
-    () => ({
-      enabled,
-      role,
-      moderator: !!role && calls.WEBINAR_MODERATORS.has(role),
-      team: !!role && calls.WEBINAR_TEAM.has(role),
-      live: !!state?.live,
-      chat: state?.chat ?? "panelists",
-      onStage,
-      handRaised: !!state?.hand_raised,
-      hands: state?.hands ?? [],
-      attendees: state?.attendees ?? [],
-      questions,
-      stageCheck: enabled && stageCheck,
-      refresh,
-      goLive: () => patch({ live: true }, "go live"),
-      end: () => patch({ live: false }, "end the webinar"),
-      setChat: (chat) => patch({ chat }, "change who can chat"),
-      setHand: async (raised) => {
-        const next = await webinarApi().setHand(callExtId, raised, linkVersion).catch(failed(raised ? "raise your hand" : "lower your hand"));
-        setState(next);
-      },
-      promote: (identity) => webinarApi().promote(callExtId, identity, linkVersion).catch(failed("bring them on stage")).then(refresh),
-      demote: (identity) => webinarApi().demote(callExtId, identity, linkVersion).catch(failed("move them to the audience")).then(refresh),
-      stepDown,
-      joinStage,
-      ask: (text) => questionAction(async () => {
-        if (!callKey) throw new Error("This call has no key.");
-        await webinarApi().questions.ask(
-          callExtId,
-          await sealQuestionText(text, callKey),
-          linkVersion
-        );
-      }, "ask the question"),
-      vote: (id, up) => questionAction(() => webinarApi().questions.vote(callExtId, id, up, linkVersion), "vote"),
-      setQuestionStatus: (id, status) => questionAction(
-        () => webinarApi().questions.update(callExtId, id, { status }, linkVersion),
-        "update the question"
-      ),
-      answer: (id, text) => questionAction(async () => {
-        if (!callKey) throw new Error("This call has no key.");
-        await webinarApi().questions.update(
-          callExtId,
-          id,
-          { answer: await sealQuestionText(text, callKey) },
-          linkVersion
-        );
-      }, "answer the question"),
-      removeQuestion: (id) => questionAction(
-        () => webinarApi().questions.delete(callExtId, id, linkVersion),
-        "delete the question"
-      )
-    }),
-    [
-      enabled,
-      role,
-      state,
-      onStage,
-      questions,
-      stageCheck,
-      refresh,
-      patch,
-      callExtId,
-      linkVersion,
-      callKey,
-      stepDown,
-      joinStage,
-      questionAction
-    ]
-  );
-}
-function useHostMuteNotice(callExtId) {
-  const room = useRoomContext();
-  useEffect(() => {
-    const notifyMuted = createMutedNotifier((text) => notify.info(text));
-    const onData = (payload, participant, _kind, topic, _encryption, participantIdentity) => {
-      if (topic !== CALL_MODERATION_TOPIC) return;
-      if (participant || participantIdentity) return;
-      const notice = mutedNoticeFromPacket(payload);
-      if (notice) notifyMuted(notice);
-    };
-    room.on(RoomEvent.DataReceived, onData);
-    const offWs = onCallEvent("call.muted", (message) => {
-      if (message.callExtId === callExtId) notifyMuted(message);
-    });
-    return () => {
-      room.off(RoomEvent.DataReceived, onData);
-      offWs();
-    };
-  }, [room, callExtId]);
-}
-
-export { DEMOTE_REJOIN_FALLBACK_MS, FINAL_SEGMENT_GRACE_MS, captureAllowed, createE2EEWorker, mayStillSend, storedSpeakerName, useCallRecorder, useCallRoom, useCallTranscriber, useHostMuteNotice, useInCallChat, useMuteRequests, useTrackUploader, useWebinar };
+export * from "./room.js";
+export * from "./useCallTranscriber.js";
+export * from "./useCallRecorder.js";
+export * from "./useInCallChat.js";
+export * from "./useWebinar.js";
+export * from "./useHostMuteNotice.js";
 //# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map