@arbidocs/react 0.5.111 → 0.5.113

package/dist/chunk-DZKRL5H3.js

@@ -1,2766 +0,0 @@
-import { clearSealedDrafts, useWorkspaces } from './chunk-4FL3X3LA.js';
-import { useArbi, arbiQueryKeys, useArbiHost, callQueryKeys } from './chunk-ZM6N7YZH.js';
-import { notify, clearChatArtifacts } from './chunk-BF5KW5ZI.js';
-import { getUserDisplayName, DEFAULT_SEGMENTER_CONFIG, INITIAL_SEGMENTER_STATE, flushSegmenter, stepSegmenter, levelFromRms } from './chunk-APZZQZ6P.js';
-import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
-import { useMemo, useSyncExternalStore, useEffect, useState, useCallback } from 'react';
-import { chats, calls, ArbiApiError, CallApiError, documents, continuityPrompt } from '@arbidocs/sdk/browser';
-import { createOfflineSealer, generateChatKey, sealCallKey, sealChatKey, decryptCallTitle, encryptWithChatKey, decryptWithChatKey, initSodium, bytesToBase64, encryptFile, decryptFile, base64ToBytes, buildCallLink, encryptCallTitle } from '@arbidocs/client';
-
-function useUserSettings(options) {
-  const arbi = useArbi();
-  return useQuery({
-    queryKey: arbiQueryKeys.userSettings(),
-    queryFn: () => arbi.settings.get(),
-    // Edited about once a month, and every write here patches the cache: no refetch on each mount.
-    staleTime: 30 * 60 * 1e3,
-    refetchOnMount: options?.refetchOnMount,
-    enabled: (options?.enabled ?? true) && arbi.isLoggedIn
-  });
-}
-function useUpdateUserSettings() {
-  const arbi = useArbi();
-  const qc = useQueryClient();
-  return useMutation({
-    mutationFn: (patch) => arbi.settings.update(patch),
-    onMutate: async (patch) => {
-      await qc.cancelQueries({ queryKey: arbiQueryKeys.userSettings() });
-      const previous = qc.getQueryData(arbiQueryKeys.userSettings());
-      qc.setQueryData(
-        arbiQueryKeys.userSettings(),
-        (old) => old ? { ...old, ...patch } : old
-      );
-      return { previous };
-    },
-    onError: (_err, _patch, context) => {
-      qc.setQueryData(arbiQueryKeys.userSettings(), context?.previous);
-    },
-    onSettled: () => qc.invalidateQueries({ queryKey: arbiQueryKeys.userSettings() })
-  });
-}
-var ALWAYS_ON = { on: true, set: () => {
-} };
-function useUnlisted() {
-  return ALWAYS_ON;
-}
-function useUserSettingSwitch(source) {
-  const { userSetting, default: fallback } = source;
-  const { data } = useUserSettings();
-  const { mutate } = useUpdateUserSettings();
-  const saved = data?.[userSetting];
-  const set = useCallback((on) => mutate({ [userSetting]: on }), [mutate, userSetting]);
-  return { on: saved ?? fallback, set };
-}
-function useLocalSwitch(source, feature) {
-  const { local, default: fallback } = source;
-  const saved = useSyncExternalStore(local.subscribe, () => local.get(feature));
-  const set = useCallback((on) => local.set(feature, on), [local, feature]);
-  return { on: saved ?? fallback, set };
-}
-function useFeatureSwitch(feature) {
-  const source = useArbiHost().features?.[feature];
-  const useSource = !source ? useUnlisted : "userSetting" in source ? useUserSettingSwitch : useLocalSwitch;
-  return useSource(source, feature);
-}
-function useFeature(feature) {
-  return useFeatureSwitch(feature).on;
-}
-function useNoSettings() {
-  return { data: void 0 };
-}
-function useFeatureCheck() {
-  const features = useArbiHost().features;
-  const useSettings = Object.values(features ?? {}).some(
-    (source) => !!source && "userSetting" in source
-  ) ? useUserSettings : useNoSettings;
-  const { data } = useSettings();
-  const locals = useMemo(() => {
-    const entries = Object.entries(features ?? {}).filter(
-      (entry) => !!entry[1] && "local" in entry[1]
-    );
-    return {
-      subscribe: (listener) => {
-        const stops = [...new Set(entries.map(([, source]) => source.local))].map(
-          (store2) => store2.subscribe(listener)
-        );
-        return () => stops.forEach((stop) => stop());
-      },
-      // A primitive snapshot, so an unrelated store write does not re-render.
-      snapshot: () => entries.map(([name, source]) => `${source.local.get(name)}`).join(",")
-    };
-  }, [features]);
-  useSyncExternalStore(locals.subscribe, locals.snapshot, locals.snapshot);
-  return (feature) => {
-    const source = features?.[feature];
-    if (!source) return true;
-    if ("local" in source) return source.local.get(feature) ?? source.default;
-    const saved = data?.[source.userSetting];
-    return saved ?? source.default;
-  };
-}
-function readLocalFeature(features, feature) {
-  const source = features[feature];
-  if (!source) return true;
-  if ("local" in source) return source.local.get(feature) ?? source.default;
-  return source.default;
-}
-function defaultStorage() {
-  try {
-    return typeof localStorage === "undefined" ? null : localStorage;
-  } catch {
-    return null;
-  }
-}
-function parseValues(raw) {
-  if (raw === null) return null;
-  try {
-    const parsed = JSON.parse(raw);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return {};
-    return Object.fromEntries(
-      Object.entries(parsed).filter(([, value]) => typeof value === "boolean")
-    );
-  } catch {
-    return {};
-  }
-}
-function createLocalFeatureStore({
-  key,
-  storage = defaultStorage(),
-  migrate
-}) {
-  const listeners4 = /* @__PURE__ */ new Set();
-  const read = () => {
-    try {
-      return storage?.getItem(key) ?? null;
-    } catch {
-      return null;
-    }
-  };
-  const write = () => {
-    try {
-      storage?.setItem(key, JSON.stringify(values));
-    } catch {
-    }
-  };
-  const notify2 = () => listeners4.forEach((listener) => listener());
-  const saved = parseValues(read());
-  let values = saved ?? {};
-  let hydrated = saved !== null || !migrate;
-  const ready = hydrated ? Promise.resolve() : migrate().catch((error) => {
-    console.warn(`[features] The saved ${key} could not be brought in`, error);
-    return null;
-  }).then((earlier) => {
-    values = { ...earlier ?? {}, ...values };
-    write();
-    hydrated = true;
-    notify2();
-  });
-  return {
-    get: (feature) => values[feature],
-    set(feature, on) {
-      if (values[feature] === on) return;
-      values = { ...values, [feature]: on };
-      write();
-      notify2();
-    },
-    subscribe(listener) {
-      listeners4.add(listener);
-      return () => listeners4.delete(listener);
-    },
-    isHydrated: () => hydrated,
-    hydrated: () => ready
-  };
-}
-
-// src/conversation-list.ts
-function isConversationListKey(queryKey) {
-  return queryKey.length === 3 && queryKey[0] === "arbi" && queryKey[1] === "conversations";
-}
-var LISTS = {
-  predicate: (query) => isConversationListKey(query.queryKey)
-};
-function patchConversationList(queryClient, workspaceId, reducer) {
-  if (!workspaceId) return;
-  const key = arbiQueryKeys.conversations(workspaceId);
-  const current = queryClient.getQueryData(key) ?? [];
-  const next = reducer(current);
-  if (next !== current) queryClient.setQueryData(key, next);
-}
-function addConversationToList(queryClient, workspaceId, conversation) {
-  patchConversationList(queryClient, workspaceId, (old) => [
-    conversation,
-    ...old.filter((c) => c.external_id !== conversation.external_id)
-  ]);
-}
-function patchConversation(queryClient, conversationId, update2) {
-  queryClient.setQueriesData(LISTS, (old) => {
-    if (!old?.some((c) => c.external_id === conversationId)) return old;
-    return old.map(
-      (c) => c.external_id === conversationId ? typeof update2 === "function" ? update2(c) : { ...c, ...update2 } : c
-    );
-  });
-}
-function removeConversationFromLists(queryClient, conversationId) {
-  queryClient.setQueriesData(
-    LISTS,
-    (old) => old?.some((c) => c.external_id === conversationId) ? old.filter((c) => c.external_id !== conversationId) : old
-  );
-}
-function invalidateConversationLists(queryClient) {
-  return queryClient.invalidateQueries(LISTS);
-}
-function findConversation(queryClient, conversationId) {
-  if (!conversationId) return void 0;
-  for (const [, list] of queryClient.getQueriesData(LISTS)) {
-    const row = list?.find((c) => c.external_id === conversationId);
-    if (row) return row;
-  }
-  return void 0;
-}
-function isConversationShared(queryClient, conversationId) {
-  return findConversation(queryClient, conversationId)?.is_shared ?? false;
-}
-function invalidateConversationDetails(queryClient, conversationId) {
-  return queryClient.invalidateQueries({
-    predicate: ({ queryKey }) => queryKey[0] === "arbi" && queryKey[1] === "conversations" && queryKey[2] === conversationId && queryKey[3] !== "threads"
-  });
-}
-function myChatId(arbi) {
-  try {
-    return arbi.user.identity()?.externalId ?? null;
-  } catch {
-    return null;
-  }
-}
-var openChatExtId = null;
-function setOpenChat(chatExtId) {
-  openChatExtId = chatExtId;
-}
-function getOpenChat() {
-  return openChatExtId;
-}
-function byActivity(a, b) {
-  const at = Date.parse(a.last_message_at ?? a.created_at);
-  const bt = Date.parse(b.last_message_at ?? b.created_at);
-  return bt - at;
-}
-function cachedChats(queryClient) {
-  return queryClient.getQueryData(arbiQueryKeys.chatList()) ?? [];
-}
-function cachedChat(queryClient, chatExtId) {
-  return cachedChats(queryClient).find((c) => c.external_id === chatExtId);
-}
-function upsertChat(queryClient, chat) {
-  queryClient.setQueryData(arbiQueryKeys.chatList(), (old) => {
-    if (!old) return old;
-    const rest = old.filter((c) => c.external_id !== chat.external_id);
-    return [chat, ...rest].sort(byActivity);
-  });
-}
-function removeChat(queryClient, chatExtId) {
-  queryClient.setQueryData(
-    arbiQueryKeys.chatList(),
-    (old) => old?.filter((c) => c.external_id !== chatExtId)
-  );
-  queryClient.removeQueries({ queryKey: arbiQueryKeys.chatThread(chatExtId) });
-}
-function appendToThread(queryClient, chatExtId, message, replaceOptimisticId) {
-  queryClient.setQueryData(arbiQueryKeys.chatThread(chatExtId), (old) => {
-    if (!old) return old;
-    const without = old.messages.filter(
-      (m) => m.external_id !== message.external_id && m.external_id !== replaceOptimisticId
-    );
-    return { ...old, messages: [...without, message] };
-  });
-}
-function dropFromThread(queryClient, chatExtId, messageExtId) {
-  queryClient.setQueryData(
-    arbiQueryKeys.chatThread(chatExtId),
-    (old) => old ? { ...old, messages: old.messages.filter((m) => m.external_id !== messageExtId) } : old
-  );
-}
-function replaceInThread(queryClient, chatExtId, message) {
-  queryClient.setQueryData(arbiQueryKeys.chatThread(chatExtId), (old) => {
-    if (!old || !old.messages.some((m) => m.external_id === message.external_id)) return old;
-    return {
-      ...old,
-      messages: old.messages.map((m) => m.external_id === message.external_id ? message : m)
-    };
-  });
-}
-function patchLastMessage(queryClient, chatExtId, message) {
-  queryClient.setQueryData(
-    arbiQueryKeys.chatList(),
-    (old) => old?.map(
-      (c) => c.external_id === chatExtId && c.last_message?.external_id === message.external_id ? { ...c, last_message: message } : c
-    )
-  );
-}
-async function deleteChatMessage(arbi, queryClient, chatExtId, messageExtId) {
-  const thread = queryClient.getQueryData(arbiQueryKeys.chatThread(chatExtId));
-  const before = thread?.messages.find((m) => m.external_id === messageExtId);
-  const listed = cachedChat(queryClient, chatExtId);
-  const wasLast = listed?.last_message?.external_id === messageExtId ? listed.last_message : null;
-  if (before) replaceInThread(queryClient, chatExtId, chats.chatMessageTombstone(before));
-  if (wasLast) patchLastMessage(queryClient, chatExtId, chats.chatMessageTombstone(wasLast));
-  try {
-    await arbi.chats.deleteMessage(chatExtId, messageExtId);
-  } catch (err) {
-    if (before) replaceInThread(queryClient, chatExtId, before);
-    if (wasLast) patchLastMessage(queryClient, chatExtId, wasLast);
-    throw err;
-  }
-}
-async function applyChangedMessage(arbi, queryClient, chatExtId, message) {
-  if (message.deleted) {
-    replaceInThread(queryClient, chatExtId, chats.chatMessageTombstone(message));
-    patchLastMessage(queryClient, chatExtId, chats.chatMessageTombstone(message));
-    return;
-  }
-  const chat = cachedChat(queryClient, chatExtId);
-  if (!chat || !queryClient.getQueryData(arbiQueryKeys.chatThread(chatExtId))) return;
-  try {
-    replaceInThread(queryClient, chatExtId, await arbi.chats.decrypt(chat, message));
-  } catch (err) {
-    console.error("[chats] could not decrypt a changed message", err);
-  }
-}
-async function applyChatMessage(arbi, queryClient, chatExtId, message) {
-  if (message.deleted) return applyChangedMessage(arbi, queryClient, chatExtId, message);
-  const me = myChatId(arbi);
-  const chat = cachedChat(queryClient, chatExtId);
-  if (!chat) {
-    void queryClient.invalidateQueries({ queryKey: arbiQueryKeys.chatList() });
-    return;
-  }
-  const mine = message.sender_ext_id === me;
-  const isOpen = openChatExtId === chatExtId;
-  upsertChat(queryClient, {
-    ...chat,
-    last_message: message,
-    last_message_at: message.created_at,
-    unread_count: mine ? 0 : isOpen ? chat.unread_count : chat.unread_count + 1,
-    members: mine ? chat.members.map(
-      (m) => m.user.external_id === me ? { ...m, last_read_at: message.created_at } : m
-    ) : chat.members
-  });
-  if (queryClient.getQueryData(arbiQueryKeys.chatThread(chatExtId))) {
-    try {
-      appendToThread(queryClient, chatExtId, await arbi.chats.decrypt(chat, message));
-    } catch (err) {
-      console.error("[chats] could not decrypt a live message", err);
-    }
-  }
-}
-function applyChatRead(arbi, queryClient, chatExtId, userExtId, lastReadAt) {
-  const me = myChatId(arbi);
-  queryClient.setQueryData(
-    arbiQueryKeys.chatList(),
-    (old) => old?.map(
-      (c) => c.external_id !== chatExtId ? c : {
-        ...c,
-        unread_count: userExtId === me ? 0 : c.unread_count,
-        members: c.members.map(
-          (m) => m.user.external_id === userExtId ? { ...m, last_read_at: lastReadAt } : m
-        )
-      }
-    )
-  );
-}
-async function applyChatUpdated(arbi, queryClient, chatExtId, message) {
-  if (message) await applyChangedMessage(arbi, queryClient, chatExtId, message);
-  let chat;
-  try {
-    chat = await arbi.chats.get(chatExtId);
-  } catch {
-    removeChat(queryClient, chatExtId);
-    return;
-  }
-  if (chat.rotation_required) {
-    chat = await arbi.chats.ready(chat).catch(() => chat);
-  }
-  upsertChat(queryClient, chat);
-  if (!message)
-    void queryClient.invalidateQueries({ queryKey: arbiQueryKeys.chatThread(chatExtId) });
-}
-function applyAgentDmStatus(queryClient, status) {
-  if (!["queued", "working", "done", "failed"].includes(status.status)) return;
-  queryClient.setQueryData(arbiQueryKeys.agentDmStatus(status.agent_ext_id), status);
-}
-async function applyChatEvent(arbi, queryClient, event) {
-  const e = event;
-  if (e.type === "chat.message")
-    return applyChatMessage(arbi, queryClient, e.chat_ext_id, e.message);
-  if (e.type === "chat.read")
-    return applyChatRead(arbi, queryClient, e.chat_ext_id, e.user_ext_id, e.last_read_at);
-  if (e.type === "chat.updated")
-    return applyChatUpdated(arbi, queryClient, e.chat_ext_id, e.message);
-  if (e.type === "agent_dm_status") applyAgentDmStatus(queryClient, e);
-}
-
-// src/calls/keys.ts
-function serverCallsExperimental(queryClient) {
-  return queryClient.getQueryData(callQueryKeys.config())?.experimental !== false;
-}
-function invalidateCall(queryClient, message) {
-  void queryClient.invalidateQueries({ queryKey: callQueryKeys.call(message.call_ext_id) });
-  const thread = message.log_conversation_ext_id;
-  if (thread) {
-    void queryClient.invalidateQueries({ queryKey: arbiQueryKeys.conversationActivity(thread) });
-  }
-}
-
-// src/calls/moderation.ts
-var CALL_MODERATION_TOPIC = "arbi.moderation";
-function trackOf(value) {
-  return value === "audio" || value === "video" ? value : null;
-}
-function mutedNoticeFromPacket(payload) {
-  try {
-    const parsed = JSON.parse(new TextDecoder().decode(payload));
-    if (!parsed || typeof parsed !== "object") return null;
-    const p = parsed;
-    const track = trackOf(p.track);
-    if (p.action !== "muted" || !track) return null;
-    return { track, byName: typeof p.by_name === "string" ? p.by_name : null };
-  } catch {
-    return null;
-  }
-}
-function mutedNoticeText(notice) {
-  return notice.track === "audio" ? "The host muted you" : "The host turned off your camera";
-}
-var MUTED_DEDUPE_MS = 5e3;
-function createMutedNotifier(show, now = Date.now) {
-  const last = /* @__PURE__ */ new Map();
-  return (notice) => {
-    const at = now();
-    const prev = last.get(notice.track);
-    if (prev !== void 0 && at - prev < MUTED_DEDUPE_MS) return;
-    last.set(notice.track, at);
-    show(mutedNoticeText(notice));
-  };
-}
-function mutedNoticeFromEvent(raw) {
-  if (!raw || typeof raw !== "object") return null;
-  const r = raw;
-  const track = trackOf(r.track);
-  if (typeof r.call_ext_id !== "string" || !track) return null;
-  return {
-    callExtId: r.call_ext_id,
-    track,
-    byName: typeof r.by_name === "string" ? r.by_name : null
-  };
-}
-var DEFAULT_JOIN_CHOICES = { audioEnabled: true, videoEnabled: false };
-var EMPTY_CALL_SESSION = {
-  active: null,
-  incoming: [],
-  knocks: [],
-  liveCalls: {}
-};
-var state = EMPTY_CALL_SESSION;
-var listeners = /* @__PURE__ */ new Set();
-function update(next) {
-  const changed = next(state);
-  if (changed === state) return;
-  state = changed;
-  for (const listener of listeners) listener();
-}
-var callSession = {
-  getState: () => state,
-  subscribe(listener) {
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  },
-  setActiveCall(next) {
-    update((s) => ({
-      ...s,
-      active: { ...next, minimized: next.minimized ?? false, startedAt: Date.now() },
-      // Joining a call answers any ring for it; knocks belong to the previous call.
-      incoming: s.incoming.filter((ring) => ring.call_ext_id !== next.callExtId),
-      knocks: s.knocks.filter((k) => k.callExtId === next.callExtId)
-    }));
-  },
-  /** Patch the active call (no-op when it is a different call or none). */
-  updateActiveCall(callExtId, patch) {
-    update(
-      (s) => s.active?.callExtId === callExtId ? { ...s, active: { ...s.active, ...patch } } : s
-    );
-  },
-  endActiveCall() {
-    update((s) => {
-      s.active?.knock?.abort();
-      return { ...s, active: null, knocks: [] };
-    });
-  },
-  setCallMinimized(minimized) {
-    update((s) => s.active ? { ...s, active: { ...s.active, minimized } } : s);
-  },
-  /** Queue a ring. A repeat ring for the same call replaces the earlier entry. */
-  enqueueIncomingCall(ring) {
-    update((s) => {
-      if (s.active?.callExtId === ring.call_ext_id) return s;
-      return {
-        ...s,
-        incoming: [
-          ...s.incoming.filter((r) => r.call_ext_id !== ring.call_ext_id),
-          { ...ring, receivedAt: Date.now() }
-        ]
-      };
-    });
-  },
-  removeIncomingCall(callExtId) {
-    update((s) => ({ ...s, incoming: s.incoming.filter((r) => r.call_ext_id !== callExtId) }));
-  },
-  addKnock(knock) {
-    update((s) => {
-      if (s.active?.callExtId !== knock.callExtId) return s;
-      return {
-        ...s,
-        knocks: [
-          ...s.knocks.filter((k) => k.knockId !== knock.knockId),
-          { ...knock, receivedAt: Date.now() }
-        ]
-      };
-    });
-  },
-  removeKnock(knockId) {
-    update((s) => ({ ...s, knocks: s.knocks.filter((k) => k.knockId !== knockId) }));
-  },
-  markCallLive(callExtId, where) {
-    update((s) => ({ ...s, liveCalls: { ...s.liveCalls, [callExtId]: where } }));
-  },
-  /** Call ended: forget it and drop any unanswered ring / knock for it. */
-  markCallEnded(callExtId) {
-    update((s) => {
-      const liveCalls = { ...s.liveCalls };
-      delete liveCalls[callExtId];
-      return {
-        ...s,
-        liveCalls,
-        incoming: s.incoming.filter((r) => r.call_ext_id !== callExtId),
-        knocks: s.knocks.filter((k) => k.callExtId !== callExtId)
-      };
-    });
-  }
-};
-function resetCallSession() {
-  update(() => EMPTY_CALL_SESSION);
-}
-function useCallSession(selector) {
-  return useSyncExternalStore(
-    callSession.subscribe,
-    () => selector(state),
-    () => selector(state)
-  );
-}
-function threadLiveCallId(s, conversationExtId) {
-  const found = Object.entries(s.liveCalls).find(
-    ([, c]) => c.logConversationExtId === conversationExtId
-  );
-  return found ? found[0] : null;
-}
-function threadHasLiveCall(s, conversationExtId) {
-  return threadLiveCallId(s, conversationExtId) !== null;
-}
-function chatLiveCallId(s, chatExtId) {
-  const found = Object.entries(s.liveCalls).find(([, c]) => c.chatExtId === chatExtId);
-  return found ? found[0] : null;
-}
-function chatHasLiveCall(s, chatExtId) {
-  return chatLiveCallId(s, chatExtId) !== null;
-}
-var listeners2 = /* @__PURE__ */ new Map();
-function onCallEvent(type, listener) {
-  let set = listeners2.get(type);
-  if (!set) listeners2.set(type, set = /* @__PURE__ */ new Set());
-  set.add(listener);
-  return () => {
-    set.delete(listener);
-  };
-}
-function relay(type, message) {
-  if (!message) return;
-  for (const listener of listeners2.get(type) ?? []) {
-    listener(message);
-  }
-}
-var str = (value) => typeof value === "string" && value ? value : null;
-function applyCallEvent(queryClient, event, options = {}) {
-  const m = event;
-  const callExtId = str(m.call_ext_id);
-  switch (m.type) {
-    case "call.ringing": {
-      const ring = m;
-      const optedOut = options.acceptRings === false && serverCallsExperimental(queryClient);
-      if (optedOut || !callExtId || !ring.sealed_key) return true;
-      if (options.me && ring.caller_ext_id === options.me) return true;
-      callSession.enqueueIncomingCall({
-        call_ext_id: ring.call_ext_id,
-        room_name: ring.room_name,
-        caller_ext_id: ring.caller_ext_id,
-        caller_name: ring.caller_name,
-        chat_ext_id: ring.chat_ext_id ?? null,
-        log_conversation_ext_id: ring.log_conversation_ext_id ?? null,
-        meeting_conversation_ext_id: ring.meeting_conversation_ext_id ?? null,
-        workspace_ext_id: ring.workspace_ext_id ?? null,
-        context: ring.context ?? null,
-        sealed_key: ring.sealed_key,
-        link_version: ring.link_version,
-        title: ring.title ?? null
-      });
-      return true;
-    }
-    case "call.declined":
-      if (callExtId && callSession.getState().active?.callExtId === callExtId) {
-        notify.info("Call declined", { record: false, ambient: false });
-      }
-      return true;
-    case "call.started":
-      if (!callExtId) return true;
-      callSession.markCallLive(callExtId, {
-        chatExtId: str(m.chat_ext_id),
-        logConversationExtId: str(m.log_conversation_ext_id),
-        meetingConversationExtId: str(m.meeting_conversation_ext_id)
-      });
-      invalidateCall(queryClient, {
-        call_ext_id: callExtId,
-        log_conversation_ext_id: str(m.log_conversation_ext_id)
-      });
-      return true;
-    case "call.ended":
-      if (!callExtId) return true;
-      callSession.markCallEnded(callExtId);
-      invalidateCall(queryClient, {
-        call_ext_id: callExtId,
-        log_conversation_ext_id: str(m.log_conversation_ext_id)
-      });
-      return true;
-    case "call.knock": {
-      const knock = m;
-      if (!callExtId) return true;
-      callSession.addKnock({
-        callExtId,
-        knockId: knock.knock_id,
-        displayName: knock.display_name,
-        userExtId: knock.user_ext_id
-      });
-      return true;
-    }
-    case "call.knock_resolved": {
-      const knockId = str(m.knock_id);
-      if (knockId) callSession.removeKnock(knockId);
-      return true;
-    }
-    case "call.recording": {
-      if (callExtId)
-        void queryClient.invalidateQueries({ queryKey: callQueryKeys.recordingsOf(callExtId) });
-      const state2 = calls.recordingStateFrom(m);
-      relay("call.recording", callExtId && state2 ? { ...state2, call_ext_id: callExtId } : null);
-      return true;
-    }
-    case "call.recording_updated": {
-      if (callExtId)
-        void queryClient.invalidateQueries({ queryKey: callQueryKeys.recordingsOf(callExtId) });
-      return true;
-    }
-    case "call.recording_deleted": {
-      if (callExtId)
-        void queryClient.invalidateQueries({ queryKey: callQueryKeys.recordingsOf(callExtId) });
-      const recordingExtId = str(m.recording_ext_id);
-      relay(
-        "call.recording_deleted",
-        callExtId && recordingExtId ? { call_ext_id: callExtId, recording_ext_id: recordingExtId } : null
-      );
-      return true;
-    }
-    case "call.transcription": {
-      const state2 = calls.transcriptionStateFrom(m);
-      relay("call.transcription", callExtId && state2 ? { ...state2, call_ext_id: callExtId } : null);
-      return true;
-    }
-    case "call.webinar":
-      relay(
-        "call.webinar",
-        callExtId && typeof m.live === "boolean" ? {
-          type: "call.webinar",
-          call_ext_id: callExtId,
-          live: m.live,
-          chat: m.chat === "everyone" ? "everyone" : "panelists"
-        } : null
-      );
-      return true;
-    case "call.muted":
-      relay("call.muted", mutedNoticeFromEvent(m));
-      return true;
-    default:
-      return false;
-  }
-}
-var OfflineMailLockedError = class extends Error {
-  constructor() {
-    super("Sign in to open the mail saved on this device");
-    this.name = "OfflineMailLockedError";
-  }
-};
-var sealer = createOfflineSealer("arbi-offline-mail-v1", {
-  locked: () => new OfflineMailLockedError()
-});
-var forgetOfflineMailKeys = sealer.forget;
-var sealBytes = sealer.sealBytes;
-var openBytes = sealer.openBytes;
-var sealJson = sealer.sealJson;
-var openJson = sealer.openJson;
-var blind = sealer.blind;
-
-// src/offline-store/store.ts
-var DB_VERSION = 1;
-var RECORDS = "records";
-var META = "meta";
-function promisify(request) {
-  return new Promise((resolve, reject) => {
-    request.onsuccess = () => resolve(request.result);
-    request.onerror = () => reject(request.error);
-  });
-}
-function createRecordStore(dbName) {
-  let dbPromise = null;
-  function openDB() {
-    if (dbPromise) return dbPromise;
-    let request;
-    try {
-      request = indexedDB.open(dbName, DB_VERSION);
-    } catch (error) {
-      return Promise.reject(error);
-    }
-    dbPromise = new Promise((resolve, reject) => {
-      request.onerror = () => {
-        dbPromise = null;
-        reject(request.error);
-      };
-      request.onsuccess = () => {
-        const db = request.result;
-        db.onversionchange = () => {
-          db.close();
-          dbPromise = null;
-        };
-        resolve(db);
-      };
-      request.onupgradeneeded = () => {
-        const db = request.result;
-        if (!db.objectStoreNames.contains(RECORDS)) {
-          const records = db.createObjectStore(RECORDS, { keyPath: "key" });
-          records.createIndex("bucket", "bucket");
-          records.createIndex("kind", "kind");
-        }
-        if (!db.objectStoreNames.contains(META)) db.createObjectStore(META, { keyPath: "key" });
-      };
-    });
-    return dbPromise;
-  }
-  async function run(store2, mode, fn) {
-    const db = await openDB();
-    return promisify(fn(db.transaction(store2, mode).objectStore(store2)));
-  }
-  async function scan(pick) {
-    const db = await openDB();
-    const store2 = db.transaction(RECORDS, "readonly").objectStore(RECORDS);
-    return new Promise((resolve, reject) => {
-      const out = [];
-      const cursor = store2.openCursor();
-      cursor.onerror = () => reject(cursor.error);
-      cursor.onsuccess = () => {
-        const c = cursor.result;
-        if (!c) return resolve(out);
-        out.push(pick(c.value));
-        c.continue();
-      };
-    });
-  }
-  const self = {
-    dbName,
-    async putRecord(record) {
-      await run(RECORDS, "readwrite", (s) => s.put(record));
-    },
-    async getRecord(key) {
-      return await run(RECORDS, "readonly", (s) => s.get(key));
-    },
-    async hasRecord(key) {
-      return await run(RECORDS, "readonly", (s) => s.count(key)) > 0;
-    },
-    async deleteRecords(keys) {
-      if (keys.length === 0) return;
-      const db = await openDB();
-      const tx = db.transaction(RECORDS, "readwrite");
-      const store2 = tx.objectStore(RECORDS);
-      for (const key of keys) store2.delete(key);
-      await new Promise((resolve, reject) => {
-        tx.oncomplete = () => resolve();
-        tx.onerror = () => reject(tx.error);
-        tx.onabort = () => reject(tx.error);
-      });
-    },
-    async recordsInBucket(bucket) {
-      return await run(
-        RECORDS,
-        "readonly",
-        (s) => s.index("bucket").getAll(bucket)
-      );
-    },
-    async recordsOfKind(kind) {
-      return await run(
-        RECORDS,
-        "readonly",
-        (s) => s.index("kind").getAll(kind)
-      );
-    },
-    allRecordSizes() {
-      return scan(({ key, kind, size }) => ({ key, kind, size }));
-    },
-    allRecordAccess() {
-      return scan(({ key, kind, lastAccess }) => ({ key, kind, lastAccess }));
-    },
-    async touchRecord(key) {
-      const record = await self.getRecord(key);
-      if (record) await self.putRecord({ ...record, lastAccess: Date.now() });
-    },
-    async getMeta(key) {
-      const row = await run(META, "readonly", (s) => s.get(key));
-      return row?.value;
-    },
-    async setMeta(key, value) {
-      await run(META, "readwrite", (s) => s.put({ key, value }));
-    },
-    async deleteDatabase() {
-      const db = await dbPromise?.catch(() => null);
-      db?.close();
-      dbPromise = null;
-      await new Promise((resolve, reject) => {
-        const request = indexedDB.deleteDatabase(dbName);
-        request.onsuccess = () => resolve();
-        request.onerror = () => reject(request.error);
-        request.onblocked = () => {
-        };
-      });
-    }
-  };
-  return self;
-}
-
-// src/mail/offline/store.ts
-var OFFLINE_MAIL_DB = "arbi-offline-mail";
-var store = createRecordStore(OFFLINE_MAIL_DB);
-var putRecord = store.putRecord;
-var getRecord = store.getRecord;
-var hasRecord = store.hasRecord;
-var deleteRecords = store.deleteRecords;
-var recordsInBucket = store.recordsInBucket;
-var recordsOfKind = store.recordsOfKind;
-var allRecordSizes = store.allRecordSizes;
-var touchRecord = store.touchRecord;
-var getMeta = store.getMeta;
-var setMeta = store.setMeta;
-var deleteOfflineMailDatabase = store.deleteDatabase;
-
-// src/mail/offline/settings.ts
-var DEFAULT_OFFLINE_MAIL_SETTINGS = {
-  enabled: true,
-  scope: "7d",
-  attachmentCapMb: 25,
-  quotaMb: 1024
-};
-var SCOPE_DAYS = {
-  "1d": 1,
-  "7d": 7,
-  "30d": 30,
-  "90d": 90
-};
-var DAY_MS = 24 * 60 * 60 * 1e3;
-function offlineWindowStart(settings, now = Date.now()) {
-  return now - SCOPE_DAYS[settings.scope] * DAY_MS;
-}
-function inOfflineWindow(settings, receivedAt, now = Date.now()) {
-  const at = receivedAt ? Date.parse(receivedAt) || 0 : 0;
-  return settings.enabled && (!at || at >= offlineWindowStart(settings, now));
-}
-function normalize(saved) {
-  const merged = { ...DEFAULT_OFFLINE_MAIL_SETTINGS, ...saved };
-  const scope = merged.scope;
-  if (scope in SCOPE_DAYS) return merged;
-  const longer = scope === "365d" || scope === "all";
-  return { ...merged, scope: longer ? "90d" : DEFAULT_OFFLINE_MAIL_SETTINGS.scope };
-}
-var STORAGE_PREFIX = "arbi-offline-mail-settings:";
-var SIGNED_OUT = { ...DEFAULT_OFFLINE_MAIL_SETTINGS, enabled: false };
-function getOfflineMailSettings(userExtId) {
-  if (!userExtId) return SIGNED_OUT;
-  const key = STORAGE_PREFIX + userExtId;
-  try {
-    const raw = localStorage.getItem(key);
-    return raw ? normalize(JSON.parse(raw)) : DEFAULT_OFFLINE_MAIL_SETTINGS;
-  } catch {
-    return DEFAULT_OFFLINE_MAIL_SETTINGS;
-  }
-}
-function setOfflineMailSettings(userExtId, patch) {
-  const next = { ...getOfflineMailSettings(userExtId), ...patch };
-  if (userExtId) {
-    try {
-      localStorage.setItem(STORAGE_PREFIX + userExtId, JSON.stringify(next));
-    } catch {
-    }
-  }
-  notifyOfflineMailChange("settings");
-  return next;
-}
-var listeners3 = /* @__PURE__ */ new Set();
-var CHANNEL = "arbi-offline-mail";
-var channel = null;
-function getChannel() {
-  if (channel || typeof BroadcastChannel === "undefined") return channel;
-  channel = new BroadcastChannel(CHANNEL);
-  channel.onmessage = (event) => {
-    for (const listener of listeners3) listener(event.data);
-  };
-  return channel;
-}
-function notifyOfflineMailChange(change) {
-  for (const listener of listeners3) listener(change);
-  try {
-    getChannel()?.postMessage(change);
-  } catch {
-  }
-}
-function onOfflineMailChange(listener) {
-  getChannel();
-  listeners3.add(listener);
-  return () => listeners3.delete(listener);
-}
-
-// src/mail/offline/wipe.ts
-var OWNER_KEY = "owner";
-async function wipeOfflineMail() {
-  forgetOfflineMailKeys();
-  await deleteOfflineMailDatabase();
-  notifyOfflineMailChange("wiped");
-}
-async function claimOfflineMail(userExtId) {
-  const owner = await getMeta(OWNER_KEY);
-  if (owner && owner !== userExtId) await wipeOfflineMail();
-  await setMeta(OWNER_KEY, userExtId);
-}
-function toProfileView(profile) {
-  return {
-    ...profile,
-    fullName: [profile.givenName, profile.familyName].map((part) => part?.trim()).filter(Boolean).join(" ")
-  };
-}
-function useProfile(options) {
-  const { client, enabled } = useAccountClient();
-  const qc = useQueryClient();
-  useEffect(
-    () => client.onProfileChange(() => qc.setQueryData(arbiQueryKeys.profile(), client.profile())),
-    [client, qc]
-  );
-  return useQuery({
-    queryKey: arbiQueryKeys.profile(),
-    queryFn: () => client.profile(),
-    enabled: (options?.enabled ?? true) && enabled,
-    staleTime: Infinity
-  });
-}
-function useUpdateProfile() {
-  const { client } = useAccountClient();
-  const qc = useQueryClient();
-  return useMutation({
-    mutationFn: async (vars) => {
-      await client.updateProfile(vars);
-      return client.profile();
-    },
-    onSuccess: (profile) => {
-      qc.setQueryData(arbiQueryKeys.profile(), profile);
-      void qc.invalidateQueries({ queryKey: arbiQueryKeys.identity() });
-      return qc.invalidateQueries({ queryKey: arbiQueryKeys.workspaces() });
-    }
-  });
-}
-function useNameEditor({ givenName, familyName, save }) {
-  const [isEditing, setIsEditing] = useState(false);
-  const [given, setGiven] = useState("");
-  const [family, setFamily] = useState("");
-  const [isSaving, setIsSaving] = useState(false);
-  const [error, setError] = useState(null);
-  const onStartEdit = useCallback(() => {
-    setGiven(givenName ?? "");
-    setFamily(familyName ?? "");
-    setError(null);
-    setIsEditing(true);
-  }, [givenName, familyName]);
-  const onSave = useCallback(() => {
-    const trimmedGiven = given.trim();
-    if (!trimmedGiven) return;
-    setIsSaving(true);
-    setError(null);
-    void Promise.resolve().then(() => save({ givenName: trimmedGiven, familyName: family.trim() })).then(() => setIsEditing(false)).catch((e) => setError(e)).finally(() => setIsSaving(false));
-  }, [given, family, save]);
-  return {
-    isEditing,
-    givenName: given,
-    familyName: family,
-    onGivenNameChange: setGiven,
-    onFamilyNameChange: setFamily,
-    onStartEdit,
-    onSave,
-    onCancel: () => setIsEditing(false),
-    isSaving,
-    error
-  };
-}
-var MAX_AVATAR_FILE_BYTES = 5 * 1024 * 1024;
-function useAvatarCrop({
-  upload,
-  onProblem,
-  maxBytes = MAX_AVATAR_FILE_BYTES
-}) {
-  const [pendingImage, setPendingImage] = useState(null);
-  const [isUploading, setIsUploading] = useState(false);
-  const onFileChosen = useCallback(
-    (file) => {
-      if (!file.type.startsWith("image/")) return onProblem?.("not-image");
-      if (file.size > maxBytes) return onProblem?.("too-large");
-      const reader = new FileReader();
-      reader.onload = () => setPendingImage(reader.result);
-      reader.onerror = () => onProblem?.("unreadable");
-      reader.readAsDataURL(file);
-    },
-    [maxBytes, onProblem]
-  );
-  const onCropComplete = useCallback(
-    (result) => {
-      setPendingImage(null);
-      setIsUploading(true);
-      void Promise.resolve().then(() => upload(result.dataUrl)).catch(() => {
-      }).finally(() => setIsUploading(false));
-    },
-    [upload]
-  );
-  return {
-    onFileChosen,
-    pendingImage,
-    onCropComplete,
-    onCropCancel: () => setPendingImage(null),
-    isUploading
-  };
-}
-
-// src/account/client.tsx
-function arbiProfile(arbi) {
-  const profile = arbi.user.profile();
-  return profile ? toProfileView(profile) : null;
-}
-function arbiAccountClient(arbi, overrides = {}) {
-  return {
-    profile: () => arbiProfile(arbi),
-    onProfileChange: (listener) => arbi.user.onProfileChange(() => listener()),
-    updateProfile: async (vars) => {
-      await arbi.profile.update({
-        ...vars.givenName !== void 0 && { given_name: vars.givenName.trim() },
-        ...vars.familyName !== void 0 && { family_name: vars.familyName.trim() },
-        ...vars.picture !== void 0 && { picture: vars.picture }
-      });
-    },
-    requestEmailChange: (newEmail) => arbi.account.requestEmailChange(newEmail),
-    confirmEmailChange: async (newEmail, code) => {
-      await arbi.account.confirmEmailChange(newEmail, code);
-    },
-    changePassword: (vars) => arbi.account.changePassword(vars),
-    listSessions: () => arbi.sessions.list(),
-    currentSessionId: () => arbi.sessions.currentId(),
-    terminateSession: (sessionId) => arbi.sessions.terminate(sessionId),
-    signOut: async ({ everywhere } = {}) => {
-      try {
-        if (everywhere) await arbi.sessions.logoutAll();
-        else await arbi.logout();
-      } finally {
-        clearSealedDrafts();
-        clearChatArtifacts();
-        await wipeOfflineMail().catch(() => {
-        });
-      }
-    },
-    requestDeletion: () => arbi.account.requestDeletion(),
-    identity: {
-      status: () => arbi.identity.status(),
-      purchase: () => arbi.identity.purchase(),
-      startSession: () => arbi.identity.startSession(),
-      refresh: () => arbi.identity.refresh(),
-      acceptName: () => arbi.identity.acceptName(),
-      remove: () => arbi.identity.remove()
-    },
-    ...overrides
-  };
-}
-var NO_ACCOUNT_ERROR = "The account needs an <ArbiHost> with `account` or an `arbi`";
-var refuse = () => Promise.reject(new Error(NO_ACCOUNT_ERROR));
-var NO_ACCOUNT = {
-  client: {
-    profile: () => null,
-    onProfileChange: () => () => {
-    },
-    updateProfile: refuse,
-    requestEmailChange: refuse,
-    confirmEmailChange: refuse,
-    changePassword: refuse,
-    listSessions: refuse,
-    currentSessionId: () => null,
-    terminateSession: refuse,
-    signOut: refuse,
-    requestDeletion: refuse,
-    identity: {
-      status: refuse,
-      purchase: refuse,
-      startSession: refuse,
-      refresh: refuse,
-      acceptName: refuse,
-      remove: refuse
-    }
-  },
-  enabled: false
-};
-var ALWAYS = () => true;
-function useAccountClient() {
-  const { account, arbi } = useArbiHost();
-  const fallback = useMemo(() => arbi ? arbiAccountClient(arbi) : null, [arbi]);
-  const useEnabled = account?.useEnabled ?? ALWAYS;
-  const enabled = useEnabled();
-  const client = account?.client;
-  const provided = useMemo(() => client ? { client, enabled } : null, [client, enabled]);
-  if (provided) return provided;
-  if (!arbi || !fallback) return NO_ACCOUNT;
-  return { client: fallback, enabled: arbi.isLoggedIn };
-}
-function useEntitlements() {
-  const { arbi } = useArbiHost();
-  return useQuery({
-    queryKey: arbiQueryKeys.entitlements(),
-    queryFn: () => arbi.account.entitlements(),
-    enabled: !!arbi?.isLoggedIn,
-    // A plan change shows on the next read; the API enforces it at once either way.
-    staleTime: 5 * 60 * 1e3
-  });
-}
-function useInvalidateEntitlements() {
-  const qc = useQueryClient();
-  return () => qc.invalidateQueries({ queryKey: arbiQueryKeys.entitlements() });
-}
-function useIsEntitled(feature) {
-  const { data } = useEntitlements();
-  return data?.[feature] === true;
-}
-function entitlementRefusal(reason) {
-  switch (reason) {
-    case "external_user":
-      return {
-        title: "Not available for external users",
-        description: "Mail, Calendar and hosting calls are for members of the firm. You can still join calls others host."
-      };
-    case "not_entitled":
-      return {
-        title: "Not available on this account",
-        description: "Mail, Calendar and hosting calls are not available on this account."
-      };
-    default:
-      return {
-        title: "Available on Pro",
-        description: "Mail, Calendar and hosting calls come with a Pro plan. You can still join calls others host."
-      };
-  }
-}
-function meetingChatRefFrom(row) {
-  if (row.chat_ext_id) return { kind: "chat", chatExtId: row.chat_ext_id };
-  const workspaceExtId = row.workspace_ext_id ?? row.locked_workspace_ext_id;
-  if (row.meeting_conversation_ext_id && workspaceExtId) {
-    return {
-      kind: "thread",
-      conversationExtId: row.meeting_conversation_ext_id,
-      workspaceExtId
-    };
-  }
-  return null;
-}
-function callMemberKeys(call) {
-  const keys = /* @__PURE__ */ new Map();
-  if (call.creator_ext_id && call.creator_encryption_public_key) {
-    keys.set(call.creator_ext_id, call.creator_encryption_public_key);
-  }
-  for (const i of call.invitees ?? []) {
-    if (i.encryption_public_key) keys.set(i.user_ext_id, i.encryption_public_key);
-  }
-  return keys;
-}
-async function publicKeysFor(arbi, queryClient, userExtIds, known) {
-  const wanted = new Set(userExtIds);
-  const keys = new Map([...known].filter(([id]) => wanted.has(id)));
-  if (![...wanted].some((id) => !keys.has(id))) return keys;
-  for (const chat of cachedChats(queryClient)) {
-    for (const m of chat.members) {
-      if (wanted.has(m.user.external_id) && !keys.has(m.user.external_id) && m.user.encryption_public_key) {
-        keys.set(m.user.external_id, m.user.encryption_public_key);
-      }
-    }
-  }
-  if ([...wanted].some((id) => !keys.has(id))) {
-    try {
-      for (const c of await arbi.contacts.list()) {
-        const u = c.user;
-        if (u && wanted.has(u.external_id) && u.encryption_public_key && !keys.has(u.external_id)) {
-          keys.set(u.external_id, u.encryption_public_key);
-        }
-      }
-    } catch (err) {
-      console.warn("[calls] could not load contacts for the meeting chat", err);
-    }
-  }
-  return keys;
-}
-async function buildMeetingChatBody(arbi, queryClient, call, callKey, extraMembers = []) {
-  if (!arbi.isLoggedIn) throw new Error("Sign in to keep the meeting chat");
-  const { externalId: me, publicKey: myPublicKey } = await arbi.chats.identity();
-  const hosts = /* @__PURE__ */ new Set([
-    call.creator_ext_id,
-    ...(call.invitees ?? []).map((i) => i.user_ext_id)
-  ]);
-  const memberIds = [.../* @__PURE__ */ new Set([...hosts, ...extraMembers])].filter(
-    (id) => id && id !== me && !chats.isAgentExtId(id)
-  );
-  const pubKeys = await publicKeysFor(arbi, queryClient, memberIds, callMemberKeys(call));
-  const key = await generateChatKey();
-  try {
-    const members = [];
-    for (const id of memberIds) {
-      const pk = pubKeys.get(id);
-      if (!pk) {
-        console.warn("[calls] no public key for meeting-chat member", id);
-        continue;
-      }
-      members.push({
-        user_ext_id: id,
-        sealed_key: await sealChatKey(key, pk),
-        ...hosts.has(id) ? {} : { call_sealed_key: await sealCallKey(callKey, pk) }
-      });
-    }
-    const title = call.title ? await decryptCallTitle(call.title, callKey) : null;
-    return {
-      title: await encryptWithChatKey(title?.trim() || "Meeting", key),
-      creator_sealed_key: await sealChatKey(key, myPublicKey),
-      members
-    };
-  } finally {
-    key.fill(0);
-  }
-}
-var pending = /* @__PURE__ */ new Map();
-function ensureMeetingChat(arbi, queryClient, callExtId, callKey) {
-  const inFlight = pending.get(callExtId);
-  if (inFlight) return inFlight;
-  const run = (async () => {
-    const call = await arbi.calls.get(callExtId);
-    const existing = meetingChatRefFrom(call);
-    if (existing) return existing;
-    const body = call.workspace_locked ? void 0 : await buildMeetingChatBody(arbi, queryClient, call, callKey);
-    const answer = await arbi.calls.chat(callExtId, body);
-    const ref = meetingChatRefFrom({
-      ...answer,
-      locked_workspace_ext_id: call.locked_workspace_ext_id
-    });
-    if (!ref) throw new Error("The server did not return a meeting chat");
-    if (ref.kind === "chat")
-      void queryClient.invalidateQueries({ queryKey: arbiQueryKeys.chatList() });
-    else void invalidateConversationLists(queryClient);
-    return ref;
-  })();
-  pending.set(callExtId, run);
-  run.catch(() => pending.delete(callExtId));
-  return run;
-}
-function clearMeetingChatCache() {
-  pending.clear();
-}
-function knownMeetingChat(target) {
-  if (target.chatExtId) return { kind: "chat", chatExtId: target.chatExtId };
-  if (target.meetingConversationExtId && target.workspaceExtId) {
-    return {
-      kind: "thread",
-      conversationExtId: target.meetingConversationExtId,
-      workspaceExtId: target.workspaceExtId
-    };
-  }
-  return null;
-}
-async function resolveMeetingChat(arbi, queryClient, target) {
-  const known = knownMeetingChat(target);
-  if (known) return known;
-  const key = target.callKey ?? await arbi.calls.key(await arbi.calls.get(target.callExtId));
-  if (!key) throw new Error("You are not invited to this call");
-  return ensureMeetingChat(arbi, queryClient, target.callExtId, key);
-}
-function sortTranscriptMessages(messages) {
-  const spokenAt = (m) => {
-    const parsed = m.decryptFailed ? null : chats.parseTranscriptContent(m.content);
-    const at = Date.parse(parsed?.started_at ?? m.created_at);
-    return Number.isNaN(at) ? 0 : at;
-  };
-  return messages.map((m, i) => ({ m, i, at: spokenAt(m) })).sort((a, b) => a.at - b.at || a.i - b.i).map(({ m }) => m);
-}
-function transcriptSegmentOf(tools) {
-  if (!tools || typeof tools !== "object") return void 0;
-  const record = tools;
-  const byKey = record.transcript_segment;
-  const candidates = byKey ? [byKey] : Object.values(record);
-  for (const c of candidates) {
-    if (!c || typeof c !== "object") continue;
-    const t = c;
-    if (c !== byKey && t.name !== "transcript_segment") continue;
-    if (typeof t.segment_id !== "string" || typeof t.speaker_ext_id !== "string") continue;
-    return {
-      segment_id: t.segment_id,
-      speaker_ext_id: t.speaker_ext_id,
-      started_at: typeof t.started_at === "string" ? t.started_at : null
-    };
-  }
-  return void 0;
-}
-var pad = (n) => String(n).padStart(2, "0");
-function clockTime(iso) {
-  if (!iso) return "";
-  const d = new Date(iso);
-  if (Number.isNaN(d.getTime())) return "";
-  return `${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
-}
-function formatTranscriptMarkdown(opts) {
-  const lines = [...opts.lines].filter((l) => l.text.trim()).sort((a, b) => (Date.parse(a.at ?? "") || 0) - (Date.parse(b.at ?? "") || 0));
-  const first = lines.find((l) => l.at)?.at;
-  const date = opts.date ?? (first ? new Date(first) : null);
-  const heading = `## Transcript: ${opts.title?.trim() || "Meeting"}`;
-  const dateLine = date ? `_${date.toLocaleDateString(void 0, { year: "numeric", month: "long", day: "numeric" })}_` : null;
-  const body = lines.map((l) => {
-    const time = clockTime(l.at);
-    return `**${l.speaker}**${time ? ` [${time}]` : ""}: ${l.text.trim().replace(/\s*\n\s*/g, " ")}`;
-  });
-  return [heading, ...dateLine ? [dateLine] : [], ...body].join("\n\n");
-}
-function threadTranscriptLines(messages, nameOf) {
-  const seen = /* @__PURE__ */ new Set();
-  const lines = [];
-  for (const m of messages) {
-    const marker = transcriptSegmentOf(m.tools);
-    if (!marker || seen.has(marker.segment_id)) continue;
-    seen.add(marker.segment_id);
-    const name = nameOf(marker.speaker_ext_id);
-    lines.push({
-      speaker: name || "Former member",
-      at: marker.started_at ?? m.created_at ?? null,
-      text: stripSpeakerPrefix(m.content ?? "", name)
-    });
-  }
-  return lines;
-}
-function stripSpeakerPrefix(content, speakerName) {
-  if (speakerName && content.startsWith(`${speakerName}: `)) {
-    return content.slice(speakerName.length + 2);
-  }
-  return content;
-}
-function isRecordingSegmentId(segmentId) {
-  return typeof segmentId === "string" && segmentId.startsWith("rec-");
-}
-function recordingWindowsOf(recordings) {
-  return recordings.map((r) => ({
-    trackExtIds: (r.tracks ?? []).map((t) => t.external_id),
-    startedAt: r.started_at,
-    stoppedAt: r.stopped_at ?? null
-  }));
-}
-function chatTranscriptRef(message) {
-  if (!chats.isTranscriptMessage(message)) return null;
-  const parsed = message.decryptFailed ? null : chats.parseTranscriptContent(message.content);
-  return { segmentId: message.dedupe_key, startedAt: parsed?.started_at ?? message.created_at };
-}
-function threadTranscriptRef(message) {
-  const marker = transcriptSegmentOf(message.tools ?? message.meta?.tools);
-  if (!marker) return null;
-  return { segmentId: marker.segment_id, startedAt: marker.started_at ?? message.created_at };
-}
-function supersededTranscriptLines(lines, refOf, recordings = []) {
-  const superseded = /* @__PURE__ */ new Set();
-  const recLines = [];
-  for (const line of lines) {
-    const ref = refOf(line);
-    if (ref && isRecordingSegmentId(ref.segmentId)) {
-      recLines.push({ segmentId: ref.segmentId, at: Date.parse(ref.startedAt ?? "") });
-    }
-  }
-  if (!recLines.length) return superseded;
-  const windows = [];
-  const claimed = /* @__PURE__ */ new Set();
-  for (const r of recordings) {
-    const prefixes = r.trackExtIds.map((t) => `rec-${t}-`);
-    const mine = recLines.filter((l) => prefixes.some((p) => l.segmentId.startsWith(p)));
-    if (!mine.length) continue;
-    for (const l of mine) claimed.add(l.segmentId);
-    const start = Date.parse(r.startedAt);
-    const stop = r.stoppedAt ? Date.parse(r.stoppedAt) : Number.POSITIVE_INFINITY;
-    if (!Number.isNaN(start)) windows.push([start, Number.isNaN(stop) ? Infinity : stop]);
-  }
-  const unclaimed = recLines.filter((l) => !claimed.has(l.segmentId) && !Number.isNaN(l.at));
-  if (unclaimed.length) {
-    const times = unclaimed.map((l) => l.at);
-    windows.push([Math.min(...times), Math.max(...times)]);
-  }
-  if (!windows.length) return superseded;
-  for (const line of lines) {
-    const ref = refOf(line);
-    if (!ref || isRecordingSegmentId(ref.segmentId)) continue;
-    const at = Date.parse(ref.startedAt ?? "");
-    if (Number.isNaN(at)) continue;
-    if (windows.some(([start, stop]) => at >= start && at <= stop)) superseded.add(line);
-  }
-  return superseded;
-}
-function supersedeLiveTranscript(lines, refOf, recordings = []) {
-  const superseded = supersededTranscriptLines(lines, refOf, recordings);
-  return superseded.size ? lines.filter((l) => !superseded.has(l)) : [...lines];
-}
-function hasRecordingTranscript(lines, refOf) {
-  return lines.some((l) => isRecordingSegmentId(refOf(l)?.segmentId));
-}
-var CALL_CHAT_TOPIC = "arbi.chat";
-var READ_ONLY_MEETING_TEXT = "Read only: you can\u2019t post in this meeting chat";
-var CALL_CHAT_MAX_CHARS = 4e3;
-var encoder = new TextEncoder();
-var decoder = new TextDecoder();
-function newPacketId() {
-  const bytes = new Uint8Array(8);
-  globalThis.crypto.getRandomValues(bytes);
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-async function encodeCallChatPacket(packet, callKey) {
-  return encoder.encode(await encryptWithChatKey(JSON.stringify(packet), callKey));
-}
-async function decodeCallChatPacket(payload, callKey) {
-  try {
-    const parsed = JSON.parse(await decryptWithChatKey(decoder.decode(payload), callKey));
-    if (!parsed || typeof parsed !== "object") return null;
-    const p = parsed;
-    if (p.v !== 1 || typeof p.id !== "string" || typeof p.text !== "string") return null;
-    const text = p.text.slice(0, CALL_CHAT_MAX_CHARS);
-    if (!text.trim()) return null;
-    return { v: 1, id: p.id, text, at: typeof p.at === "number" ? p.at : Date.now() };
-  } catch {
-    return null;
-  }
-}
-async function chatByExtId(arbi, queryClient, chatExtId) {
-  return cachedChat(queryClient, chatExtId) ?? arbi.chats.get(chatExtId);
-}
-async function persistMeetingMessage(arbi, queryClient, callExtId, callKey, text) {
-  const ref = await ensureMeetingChat(arbi, queryClient, callExtId, callKey);
-  if (ref.kind === "chat") {
-    await arbi.chats.send(await chatByExtId(arbi, queryClient, ref.chatExtId), text);
-  } else {
-    try {
-      await arbi.conversations.postMessage({
-        content: text,
-        conversation_ext_id: ref.conversationExtId,
-        assistant_mode: "mentioned"
-      });
-    } catch (err) {
-      const status = err instanceof ArbiApiError ? err.status : void 0;
-      const detail = err instanceof ArbiApiError ? err.detail : void 0;
-      throw new Error(
-        `Could not save the message to the meeting thread (${status ?? "?"})${detail ? `: ${detail}` : ""}`
-      );
-    }
-  }
-  return ref;
-}
-var HISTORY_LIMIT = 50;
-async function loadMeetingHistory(arbi, queryClient, callExtId) {
-  const ref = meetingChatRefFrom(await arbi.calls.get(callExtId));
-  if (!ref) return null;
-  if (ref.kind === "chat") {
-    const chat = await chatByExtId(arbi, queryClient, ref.chatExtId);
-    const page = await arbi.chats.page(chat);
-    const names = new Map(chat.members.map((m) => [m.user.external_id, getUserDisplayName(m.user)]));
-    return {
-      ref,
-      messages: page.messages.filter((m) => m.kind === "text" && !m.decryptFailed && m.content).slice(-HISTORY_LIMIT).map((m) => ({
-        id: m.external_id,
-        senderExtId: m.sender_ext_id ?? null,
-        senderName: m.sender_ext_id && names.get(m.sender_ext_id) || null,
-        text: m.content ?? "",
-        at: Date.parse(m.created_at)
-      }))
-    };
-  }
-  const data = await arbi.conversations.getThreads(ref.conversationExtId).catch(() => null);
-  if (!data) return { ref, messages: [] };
-  const seen = /* @__PURE__ */ new Map();
-  for (const thread of data.threads) {
-    for (const m of thread.history) {
-      if (seen.has(m.external_id) || m.role === "system" || !m.content) continue;
-      if (transcriptSegmentOf(m.tools)) continue;
-      seen.set(m.external_id, {
-        id: m.external_id,
-        senderExtId: m.role === "assistant" ? null : m.created_by_ext_id,
-        senderName: m.role === "assistant" ? "ARBI" : null,
-        text: m.content,
-        at: Date.parse(m.created_at)
-      });
-    }
-  }
-  return {
-    ref,
-    messages: [...seen.values()].sort((a, b) => a.at - b.at).slice(-HISTORY_LIMIT)
-  };
-}
-var SAME_MESSAGE_MS = 5 * 60 * 1e3;
-function mergeChatLines(history, live, context) {
-  const historyLines = history.map((m) => ({
-    id: `h:${m.id}`,
-    senderIdentity: m.senderExtId ?? "arbi",
-    senderName: m.senderName ?? (m.senderExtId ? context.nameOf(m.senderExtId) : null) ?? "Someone",
-    text: m.text,
-    at: m.at,
-    mine: !!m.senderExtId && m.senderExtId === context.myIdentity,
-    status: "history"
-  }));
-  const used = /* @__PURE__ */ new Set();
-  const liveOnly = live.filter((line) => {
-    const match = history.findIndex(
-      (m, i) => !used.has(i) && m.senderExtId === line.senderIdentity && m.text === line.text && Math.abs(m.at - line.at) < SAME_MESSAGE_MS
-    );
-    if (match < 0) return true;
-    used.add(match);
-    return false;
-  });
-  return [...historyLines, ...liveOnly].sort((a, b) => a.at - b.at);
-}
-var CALL_RECORDING_TOPIC = "arbi.recording";
-var RECORDING_CHUNK_MS = 3e4;
-var SPEAKER_AUDIO_BITS_PER_SECOND = 24e3;
-var COMPOSITE_VIDEO_BITS_PER_SECOND = 5e5;
-var COMPOSITE_AUDIO_BITS_PER_SECOND = 32e3;
-function partOffsetMs(partStartedAt, recordingStartedAt) {
-  const start = typeof recordingStartedAt === "number" ? recordingStartedAt : Date.parse(recordingStartedAt);
-  if (!Number.isFinite(start)) return 0;
-  return Math.max(0, Math.round(partStartedAt - start));
-}
-function newTrackKey() {
-  return generateChatKey();
-}
-async function wrapTrackKey(fileKey, conversationKey) {
-  await initSodium();
-  return bytesToBase64(encryptFile(fileKey, conversationKey));
-}
-async function unwrapTrackKey(wrapped, conversationKey) {
-  await initSodium();
-  return decryptFile(base64ToBytes(wrapped), conversationKey);
-}
-async function encryptPart(bytes, fileKey) {
-  await initSodium();
-  return encryptFile(bytes, fileKey);
-}
-async function decryptPart(cipher, fileKey) {
-  await initSodium();
-  return decryptFile(cipher, fileKey);
-}
-async function conversationKeyForCall(arbi, queryClient, call, options = {}) {
-  if (call.workspace_locked && call.locked_workspace_ext_id) {
-    const key2 = await arbi.workspaces.key(call.locked_workspace_ext_id);
-    return { key: key2, keyVersion: null };
-  }
-  let chatExtId = call.chat_ext_id ?? null;
-  if (!chatExtId) {
-    if (!options.callKey) throw new Error("This call has no meeting chat to keep a recording in");
-    const ref = await ensureMeetingChat(arbi, queryClient, call.external_id, options.callKey);
-    if (ref.kind !== "chat") throw new Error("Expected an end-to-end meeting chat");
-    chatExtId = ref.chatExtId;
-  }
-  const chat = await arbi.chats.ready(await chatByExtId(arbi, queryClient, chatExtId));
-  const ring = await arbi.chats.ring(chat);
-  const version = options.keyVersion ?? ring.currentVersion;
-  const key = ring.keys.get(version);
-  if (!key) throw new Error("No key for this recording in the meeting chat");
-  return { key, keyVersion: version };
-}
-async function meetingRefForCall(arbi, queryClient, call, callKey) {
-  const ref = meetingChatRefFrom(call);
-  if (ref) return ref;
-  if (!callKey) throw new Error("This call has no meeting chat yet");
-  return ensureMeetingChat(arbi, queryClient, call.external_id, callKey);
-}
-var defaultDeps = (arbi) => ({
-  createTrack: (...args) => arbi.calls.recording.createTrack(...args),
-  presign: (...args) => arbi.calls.recording.presignPart(...args),
-  commit: (...args) => arbi.calls.recording.commitPart(...args),
-  getRecording: (...args) => arbi.calls.recording.get(...args),
-  put: (url, body, headers) => documents.presignedPut(url, body, void 0, headers),
-  encrypt: encryptPart,
-  wrap: wrapTrackKey,
-  unwrap: unwrapTrackKey,
-  newKey: newTrackKey,
-  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms))
-});
-var UPLOAD_ATTEMPTS = 5;
-var UPLOAD_BACKOFF_MS = 1e3;
-var SeqTakenError = class extends Error {
-};
-function isRetryable(err) {
-  if (!(err instanceof CallApiError)) return true;
-  if (calls.isQuotaError(err)) return false;
-  if (err.code === "part_not_uploaded") return true;
-  const s = err.status ?? 0;
-  return s === 0 || s === 408 || s === 429 || s >= 500 && s !== 507;
-}
-function isRecordingOver(err) {
-  if (!(err instanceof CallApiError)) return false;
-  return err.code === "recording_stopped" || err.code === "composite_needs_video" || err.status === 404 || err.status === 410;
-}
-var TrackUploader = class {
-  constructor(options) {
-    this.options = options;
-    this.deps = { ...defaultDeps(options.arbi), ...options.deps };
-  }
-  options;
-  deps;
-  track = null;
-  trackPromise = null;
-  nextSeq = 0;
-  queue = [];
-  running = null;
-  /** No more parts are accepted (quota, or the recording is gone). */
-  stopped = false;
-  /** Parts committed (for tests and the UI). */
-  committed = 0;
-  /** Queue a part; parts upload one at a time, in order. */
-  enqueue(part) {
-    if (this.stopped) return;
-    this.queue.push(part);
-    this.drain();
-  }
-  /** Resolves once every queued part was uploaded (or given up). */
-  async flush() {
-    while (this.running) await this.running;
-  }
-  drain() {
-    if (this.running) return;
-    this.running = (async () => {
-      try {
-        while (this.queue.length && !this.stopped) {
-          const part = this.queue.shift();
-          await this.uploadPart(part);
-        }
-      } finally {
-        this.running = null;
-      }
-    })();
-  }
-  async withRetry(label, run) {
-    let lastError;
-    for (let attempt = 0; attempt < UPLOAD_ATTEMPTS; attempt++) {
-      try {
-        return await run();
-      } catch (err) {
-        lastError = err;
-        if (!isRetryable(err) || attempt === UPLOAD_ATTEMPTS - 1) break;
-        console.warn(`[calls] recording ${label} failed, retrying`, err);
-        await this.deps.sleep(UPLOAD_BACKOFF_MS * 2 ** attempt);
-      }
-    }
-    throw lastError;
-  }
-  ensureTrack() {
-    if (this.track) return Promise.resolve(this.track);
-    if (!this.trackPromise) {
-      this.trackPromise = this.withRetry("track", () => this.createTrack()).then(
-        (track) => {
-          this.track = track;
-          return track;
-        },
-        (err) => {
-          this.trackPromise = null;
-          throw err;
-        }
-      );
-    }
-    return this.trackPromise;
-  }
-  async createTrack() {
-    const { callExtId, recordingExtId, kind, mimeType } = this.options;
-    const conv = await this.options.conversationKey();
-    const fileKey = await this.deps.newKey();
-    const wrapped = await this.deps.wrap(fileKey, conv.key);
-    const created = await this.deps.createTrack(callExtId, recordingExtId, {
-      kind,
-      wrapped_key: wrapped,
-      key_version: conv.keyVersion,
-      mime_type: mimeType,
-      ...this.options.linkVersion ? { link_version: this.options.linkVersion } : {}
-    });
-    const key = created.wrapped_key && created.wrapped_key !== wrapped ? await this.deps.unwrap(created.wrapped_key, conv.key) : fileKey;
-    let startedAt = this.options.recordingStartedAt ?? null;
-    let parts = created.parts;
-    if (!startedAt || !parts) {
-      const recording = await this.deps.getRecording(callExtId, recordingExtId);
-      startedAt = startedAt ?? recording.started_at;
-      parts = parts ?? (recording.tracks ?? []).find((t) => t.external_id === created.external_id)?.parts;
-    }
-    this.nextSeq = Math.max(this.nextSeq, nextSeqAfter(parts ?? []));
-    return { externalId: created.external_id, fileKey: key, startedAt };
-  }
-  async uploadPart(part) {
-    const { callExtId, recordingExtId } = this.options;
-    try {
-      const track = await this.ensureTrack();
-      const bytes = new Uint8Array(await part.blob.arrayBuffer());
-      const cipher = await this.deps.encrypt(bytes, track.fileKey);
-      const offset = partOffsetMs(part.startedAt, track.startedAt);
-      let seq = this.nextSeq++;
-      await this.withRetry("part", async () => {
-        let upload;
-        try {
-          upload = await this.deps.presign(callExtId, recordingExtId, track.externalId, {
-            seq,
-            offset_ms: offset,
-            duration_ms: Math.max(0, Math.round(part.durationMs)),
-            size_bytes: cipher.length
-          });
-        } catch (err) {
-          if (err instanceof CallApiError && err.code === "part_committed") {
-            seq = this.nextSeq++;
-            throw new SeqTakenError(err.message);
-          }
-          throw err;
-        }
-        await this.deps.put(upload.upload_url, cipher, upload.headers ?? void 0);
-        await this.deps.commit(callExtId, recordingExtId, track.externalId, seq);
-      });
-      this.committed += 1;
-    } catch (err) {
-      if (calls.isQuotaError(err)) {
-        this.stopped = true;
-        this.queue = [];
-        this.options.onStopped?.(err);
-        return;
-      }
-      if (isRecordingOver(err)) {
-        this.stopped = true;
-        this.queue = [];
-      }
-      console.warn("[calls] a recording part could not be kept", err);
-      this.options.onPartLost?.(err);
-    }
-  }
-};
-function nextSeqAfter(parts) {
-  return parts.reduce((max, p) => Math.max(max, p.seq + 1), 0);
-}
-var uploaders = /* @__PURE__ */ new Map();
-function trackUploaderFor(options) {
-  const key = `${options.recordingExtId}:${options.kind}`;
-  let uploader = uploaders.get(key);
-  if (!uploader || uploader.stopped) {
-    uploader = new TrackUploader(options);
-    uploaders.set(key, uploader);
-  }
-  return uploader;
-}
-function clearTrackUploaders() {
-  uploaders.clear();
-}
-
-// src/calls/recording-playback.ts
-var partKey = (p) => `${p.trackExtId}:${p.seq}`;
-function timelineOf(tracks) {
-  return tracks.flatMap(
-    (t) => (t.parts ?? []).map((p) => ({
-      trackExtId: t.external_id,
-      seq: p.seq,
-      offsetMs: p.offset_ms,
-      durationMs: p.duration_ms
-    }))
-  ).sort((a, b) => a.offsetMs - b.offsetMs || a.seq - b.seq);
-}
-function timelineDurationMs(parts) {
-  return parts.reduce((max, p) => Math.max(max, p.offsetMs + p.durationMs), 0);
-}
-var PLAYBACK_LOOKAHEAD_MS = 2e4;
-function partsDue(parts, playheadMs, lookaheadMs, scheduled) {
-  return parts.filter(
-    (p) => !scheduled.has(partKey(p)) && p.offsetMs < playheadMs + lookaheadMs && p.offsetMs + p.durationMs > playheadMs
-  );
-}
-function schedulePart(params) {
-  const { partOffsetMs: partOffsetMs2, bufferDurationS, ctxStart, seekMs, ctxNow } = params;
-  let when = ctxStart + (partOffsetMs2 - seekMs) / 1e3;
-  let offset = 0;
-  if (when < ctxNow) {
-    offset = ctxNow - when;
-    when = ctxNow;
-  }
-  if (offset >= bufferDurationS) return null;
-  return { when, offset };
-}
-function playheadAt(ctxNow, ctxStart, seekMs) {
-  return seekMs + Math.max(0, ctxNow - ctxStart) * 1e3;
-}
-var EBML_MAGIC = [26, 69, 223, 163];
-var FTYP = [102, 116, 121, 112];
-function startsMediaFile(bytes) {
-  if (EBML_MAGIC.every((b, i) => bytes[i] === b)) return true;
-  return FTYP.every((b, i) => bytes[4 + i] === b);
-}
-function splitIntoFiles(parts) {
-  const files = [];
-  for (const part of parts) {
-    if (!files.length || startsMediaFile(part)) files.push([part]);
-    else files[files.length - 1].push(part);
-  }
-  return files;
-}
-function extensionFor(mimeType) {
-  if (mimeType.includes("mp4")) return mimeType.startsWith("video") ? "mp4" : "m4a";
-  if (mimeType.includes("ogg")) return "ogg";
-  return "webm";
-}
-function fileSafe(name) {
-  return name.replace(/[^\p{L}\p{N} ._-]+/gu, "").trim().replace(/\s+/g, "-").slice(0, 60) || "recording";
-}
-var EXPORT_SAMPLE_RATE = 16e3;
-function writeSamples(target, samples, offsetSamples) {
-  const start = Math.max(0, Math.round(offsetSamples));
-  const n = Math.min(samples.length, target.length - start);
-  for (let i = 0; i < n; i++) {
-    const s = Math.max(-1, Math.min(1, samples[i]));
-    target[start + i] = s < 0 ? s * 32768 : s * 32767;
-  }
-}
-function encodeWav(samples, sampleRate) {
-  const dataBytes = samples.length * 2;
-  const out = new Uint8Array(44 + dataBytes);
-  const view = new DataView(out.buffer);
-  const ascii = (offset, text) => {
-    for (let i = 0; i < text.length; i++) out[offset + i] = text.charCodeAt(i);
-  };
-  ascii(0, "RIFF");
-  view.setUint32(4, 36 + dataBytes, true);
-  ascii(8, "WAVE");
-  ascii(12, "fmt ");
-  view.setUint32(16, 16, true);
-  view.setUint16(20, 1, true);
-  view.setUint16(22, 1, true);
-  view.setUint32(24, sampleRate, true);
-  view.setUint32(28, sampleRate * 2, true);
-  view.setUint16(32, 2, true);
-  view.setUint16(34, 16, true);
-  ascii(36, "data");
-  view.setUint32(40, dataBytes, true);
-  for (let i = 0; i < samples.length; i++) view.setInt16(44 + i * 2, samples[i], true);
-  return out;
-}
-function standalone(bytes) {
-  return new Uint8Array(bytes);
-}
-function floatToWav(samples, sampleRate) {
-  const pcm = new Int16Array(samples.length);
-  writeSamples(pcm, samples, 0);
-  return encodeWav(pcm, sampleRate);
-}
-var SEGMENT_FRAME_MS = 50;
-var SEGMENT_PRE_ROLL_MS = 200;
-var RECORDING_SEGMENTER = {
-  maxMs: 25e3,
-  minVoiceMs: 300,
-  silenceMs: 1500
-};
-var SHORT_PIECE_MERGE_GAP_MS = 1e3;
-function createTrackCutter(sampleRate, config = {}, options = {}) {
-  const cfg = { ...DEFAULT_SEGMENTER_CONFIG, ...config };
-  const frame = Math.max(1, Math.round(sampleRate * SEGMENT_FRAME_MS / 1e3));
-  const preRoll = Math.round(SEGMENT_PRE_ROLL_MS / 1e3 * sampleRate);
-  const toSample = (ms) => Math.round(ms / 1e3 * sampleRate);
-  const toMs = (sample) => sample / sampleRate * 1e3;
-  let buf = new Float32Array(sampleRate * 4);
-  let bufStart = 0;
-  let len = 0;
-  let origin = null;
-  let cursor = 0;
-  let nextFrame = 0;
-  let state2 = INITIAL_SEGMENTER_STATE;
-  let pending2 = null;
-  let out = [];
-  const append = (samples) => {
-    if (len + samples.length > buf.length) {
-      const grown = new Float32Array(Math.max(buf.length * 2, len + samples.length));
-      grown.set(buf.subarray(0, len));
-      buf = grown;
-    }
-    buf.set(samples, len);
-    len += samples.length;
-    cursor += samples.length;
-  };
-  const emit = (piece) => {
-    const from = Math.max(piece.start, bufStart);
-    if (piece.end <= from) return;
-    out.push({
-      start: from,
-      end: piece.end,
-      voiceMs: piece.voiceMs,
-      samples: buf.slice(from - bufStart, piece.end - bufStart)
-    });
-  };
-  const onEvents = (events) => {
-    for (const e of events) {
-      if (e.type === "start") {
-        if (pending2 && e.at - pending2.at > SHORT_PIECE_MERGE_GAP_MS) pending2 = null;
-        continue;
-      }
-      let piece = {
-        start: Math.max(origin ?? 0, toSample(e.startedAt) - preRoll),
-        end: Math.min(cursor, toSample(e.at)),
-        voiceMs: e.voiceMs,
-        at: e.at
-      };
-      if (pending2) {
-        if (piece.end - pending2.start <= toSample(cfg.maxMs) + preRoll) {
-          piece = { ...piece, start: pending2.start, voiceMs: piece.voiceMs + pending2.voiceMs };
-        }
-        pending2 = null;
-      }
-      if (piece.voiceMs >= cfg.minVoiceMs) emit(piece);
-      else if (options.mergeShort && piece.end > piece.start) pending2 = piece;
-    }
-  };
-  const step = (from, n) => {
-    let sum = 0;
-    const base = from - bufStart;
-    for (let j = 0; j < n; j++) sum += buf[base + j] * buf[base + j];
-    const result = stepSegmenter(state2, levelFromRms(Math.sqrt(sum / n)), toMs(from), cfg);
-    state2 = result.state;
-    onEvents(result.events);
-  };
-  const run = () => {
-    while (nextFrame + frame <= cursor) {
-      step(nextFrame, frame);
-      nextFrame += frame;
-    }
-    let keepFrom = cursor - preRoll;
-    if (state2.phase === "voice") keepFrom = Math.min(keepFrom, toSample(state2.startedAt) - preRoll);
-    if (pending2) keepFrom = Math.min(keepFrom, pending2.start);
-    keepFrom = Math.min(Math.max(keepFrom, bufStart), nextFrame);
-    if (keepFrom > bufStart) {
-      buf.copyWithin(0, keepFrom - bufStart, len);
-      len -= keepFrom - bufStart;
-      bufStart = keepFrom;
-    }
-  };
-  const take = () => {
-    const done = out;
-    out = [];
-    return done;
-  };
-  return {
-    push(offsetMs, samples) {
-      const at = toSample(Math.max(0, offsetMs));
-      if (origin === null) {
-        origin = at;
-        bufStart = cursor = nextFrame = at;
-      }
-      if (at > cursor) {
-        const second = new Float32Array(sampleRate);
-        while (cursor < at) {
-          append(second.subarray(0, Math.min(sampleRate, at - cursor)));
-          run();
-        }
-      }
-      const fresh = at < cursor ? samples.subarray(Math.min(samples.length, cursor - at)) : samples;
-      if (fresh.length) {
-        append(fresh);
-        run();
-      }
-      return take();
-    },
-    finish() {
-      if (origin !== null) {
-        if (nextFrame < cursor) {
-          step(nextFrame, cursor - nextFrame);
-          nextFrame = cursor;
-        }
-        onEvents(flushSegmenter(state2, toMs(cursor), cfg).events);
-        state2 = INITIAL_SEGMENTER_STATE;
-      }
-      pending2 = null;
-      return take();
-    }
-  };
-}
-function cutAtPauses(samples, sampleRate, config = {}) {
-  const cutter = createTrackCutter(sampleRate, config);
-  return [...cutter.push(0, samples), ...cutter.finish()].map(({ start, end }) => ({ start, end }));
-}
-var CALL_CAPTION_TOPIC = "arbi.caption";
-var CALL_TRANSCRIPTION_TOPIC = "arbi.transcription";
-var CAPTION_MAX_CHARS = 2e3;
-var LIVE_SEGMENTER = { minVoiceMs: 400, holdShortMs: 1e3 };
-var encoder2 = new TextEncoder();
-var decoder2 = new TextDecoder();
-var SEGMENT_ID_PATTERN = /^[A-Za-z0-9_-]{8,64}$/;
-function newSegmentId() {
-  const bytes = new Uint8Array(12);
-  globalThis.crypto.getRandomValues(bytes);
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
-}
-async function encodeCaptionPacket(packet, callKey) {
-  return encoder2.encode(await encryptWithChatKey(JSON.stringify(packet), callKey));
-}
-async function decodeCaptionPacket(payload, callKey) {
-  try {
-    const parsed = JSON.parse(await decryptWithChatKey(decoder2.decode(payload), callKey));
-    if (!parsed || typeof parsed !== "object") return null;
-    const p = parsed;
-    if (p.v !== 1 || typeof p.segment_id !== "string" || !SEGMENT_ID_PATTERN.test(p.segment_id) || typeof p.text !== "string" || typeof p.identity !== "string") {
-      return null;
-    }
-    const text = p.text.trim().slice(0, CAPTION_MAX_CHARS);
-    if (!text) return null;
-    return {
-      v: 1,
-      segment_id: p.segment_id,
-      text,
-      identity: p.identity,
-      name: typeof p.name === "string" ? p.name : p.identity,
-      t: typeof p.t === "number" ? p.t : Date.now(),
-      ...p.proxy === true ? { proxy: true } : {}
-    };
-  } catch {
-    return null;
-  }
-}
-function transcriptPersistRole(params) {
-  if (!params.canPost || !params.hasCallKey) return null;
-  if (params.speakerIdentity === params.myIdentity) return "own";
-  if (params.speakerNeedsProxy) return "proxy";
-  return null;
-}
-function threadTranscriptText(segment) {
-  return `${segment.speakerName}: ${segment.text}`;
-}
-async function persistTranscriptSegment(arbi, queryClient, callExtId, callKey, segment) {
-  const ref = await ensureMeetingChat(arbi, queryClient, callExtId, callKey);
-  await storeTranscriptSegment(arbi, queryClient, ref, segment);
-  return ref;
-}
-async function storeTranscriptSegment(arbi, queryClient, ref, segment) {
-  if (ref.kind === "chat") {
-    const chat = await arbi.chats.ready(await chatByExtId(arbi, queryClient, ref.chatExtId));
-    const ring = await arbi.chats.ring(chat);
-    const key = ring.keys.get(ring.currentVersion);
-    if (!key) throw new Error("No key for the meeting chat");
-    const content = {
-      text: segment.text,
-      speaker_identity: segment.speakerIdentity,
-      speaker_name: segment.speakerName,
-      started_at: segment.startedAt
-    };
-    await arbi.calls.transcription.postChatLine(ref.chatExtId, {
-      content: await encryptWithChatKey(JSON.stringify(content), key),
-      key_version: ring.currentVersion,
-      dedupe_key: segment.segmentId
-    });
-    return;
-  }
-  const transcript = {
-    segment_id: segment.segmentId,
-    speaker_ext_id: segment.speakerIdentity,
-    started_at: segment.startedAt
-  };
-  await arbi.conversations.postMessage({
-    content: threadTranscriptText(segment),
-    conversation_ext_id: ref.conversationExtId,
-    assistant_mode: "mentioned",
-    transcript
-  });
-}
-async function openRecording(arbi, queryClient, call, recordingExtId, loaded) {
-  const recording = loaded ?? await arbi.calls.recording.get(call.external_id, recordingExtId);
-  const convKeys = /* @__PURE__ */ new Map();
-  const keys = /* @__PURE__ */ new Map();
-  for (const track of recording.tracks ?? []) {
-    const version = track.key_version ?? null;
-    const id = String(version);
-    if (!convKeys.has(id)) {
-      convKeys.set(
-        id,
-        conversationKeyForCall(arbi, queryClient, call, { keyVersion: version }).then((c) => c.key)
-      );
-    }
-    try {
-      keys.set(track.external_id, await unwrapTrackKey(track.wrapped_key, await convKeys.get(id)));
-    } catch (err) {
-      console.warn("[calls] a recording track key does not open", err);
-    }
-  }
-  return { recording, keys };
-}
-function speakerTracks(recording) {
-  return (recording.tracks ?? []).filter((t) => t.kind === "speaker");
-}
-function compositeTrack(recording) {
-  return (recording.tracks ?? []).find((t) => t.kind === "composite") ?? null;
-}
-function sortedParts(track) {
-  return [...track.parts ?? []].sort((a, b) => a.seq - b.seq);
-}
-async function fetchPart(arbi, part, fileKey) {
-  if (!part.download_url) throw new Error("This recording\u2019s media was deleted");
-  return decryptPart(await arbi.calls.recording.downloadPart(part.download_url), fileKey);
-}
-async function compositeFiles(arbi, track, fileKey) {
-  const parts = [];
-  for (const part of sortedParts(track)) parts.push(await fetchPart(arbi, part, fileKey));
-  const type = track.mime_type.split(";")[0] || "video/webm";
-  return splitIntoFiles(parts).map((file) => new Blob(file.map(standalone), { type }));
-}
-async function decodeMono16k(bytes) {
-  const ctx = new OfflineAudioContext(1, 1, EXPORT_SAMPLE_RATE);
-  const buffer = await ctx.decodeAudioData(standalone(bytes).buffer);
-  return buffer.getChannelData(0);
-}
-async function speakerWav(arbi, track, fileKey, onPart) {
-  const parts = sortedParts(track);
-  const totalMs = timelineDurationMs(timelineOf([track]));
-  const samples = new Int16Array(Math.ceil(totalMs / 1e3 * EXPORT_SAMPLE_RATE) + 1);
-  for (const part of parts) {
-    const bytes = await fetchPart(arbi, part, fileKey);
-    try {
-      writeSamples(
-        samples,
-        await decodeMono16k(bytes),
-        part.offset_ms / 1e3 * EXPORT_SAMPLE_RATE
-      );
-    } catch (err) {
-      console.warn("[calls] a recording part does not decode", err);
-    }
-    onPart?.();
-  }
-  return new Blob([encodeWav(samples, EXPORT_SAMPLE_RATE)], { type: "audio/wav" });
-}
-async function recordingFiles(arbi, opened, title, onProgress) {
-  const { recording, keys } = opened;
-  const base = fileSafe(title || "Meeting");
-  const date = recording.started_at.slice(0, 10);
-  const total = (recording.tracks ?? []).reduce((n, t) => n + (t.parts?.length ?? 0), 0);
-  let done = 0;
-  const tick = () => onProgress?.(++done, total);
-  const files = [];
-  for (const track of speakerTracks(recording)) {
-    const key = keys.get(track.external_id);
-    if (!key || !track.parts?.length) continue;
-    const wav = await speakerWav(arbi, track, key, tick);
-    const who = fileSafe(track.speaker_name || track.speaker_ext_id || "speaker");
-    files.push(new File([wav], `${base}-${date}-${who}.wav`, { type: "audio/wav" }));
-  }
-  const composite = compositeTrack(recording);
-  const compositeKey = composite && keys.get(composite.external_id);
-  if (composite && compositeKey && composite.parts?.length) {
-    const videos = await compositeFiles(arbi, composite, compositeKey);
-    done += composite.parts.length;
-    onProgress?.(done, total);
-    const ext = extensionFor(composite.mime_type);
-    videos.forEach(
-      (blob, i) => files.push(
-        new File([blob], `${base}-${date}-video${videos.length > 1 ? `-${i + 1}` : ""}.${ext}`, {
-          type: blob.type
-        })
-      )
-    );
-  }
-  return files;
-}
-var PROMPT_HISTORY_CHARS = 400;
-async function transcribeRecording(params) {
-  const {
-    arbi,
-    queryClient,
-    callExtId,
-    opened,
-    ref,
-    onProgress,
-    decode = decodeMono16k,
-    language
-  } = params;
-  const { recording, keys } = opened;
-  const tracks = speakerTracks(recording).filter((t) => keys.has(t.external_id));
-  const total = tracks.reduce((n, t) => n + (t.parts?.length ?? 0), 0);
-  const start = Date.parse(recording.started_at);
-  let done = 0;
-  let stored = 0;
-  let failed = 0;
-  for (const track of tracks) {
-    const key = keys.get(track.external_id);
-    const cutter = createTrackCutter(EXPORT_SAMPLE_RATE, RECORDING_SEGMENTER, { mergeShort: true });
-    let previous = "";
-    let nextSegment = 0;
-    const send = async (request) => {
-      try {
-        const result = await arbi.calls.recording.transcribe(callExtId, recording.external_id, {
-          audio: request.audio,
-          trackExtId: track.external_id,
-          seq: request.seq ?? null,
-          segment: request.segment ?? null,
-          segmentOffsetMs: request.seq == null ? request.offsetMs : 0,
-          language,
-          prompt: continuityPrompt(previous)
-        });
-        const text = result.text.trim();
-        if (!text) return;
-        previous = `${previous} ${text}`.slice(-PROMPT_HISTORY_CHARS);
-        const segment = {
-          segmentId: result.segment_id || (request.seq != null ? `rec-${track.external_id}-${request.seq}` : `rec-${track.external_id}-s${request.segment}`),
-          text,
-          speakerIdentity: result.speaker_ext_id ?? track.speaker_ext_id ?? "",
-          speakerName: result.speaker_name ?? track.speaker_name ?? "Speaker",
-          startedAt: Number.isFinite(start) ? new Date(start + (result.offset_ms ?? Math.round(request.offsetMs))).toISOString() : null
-        };
-        await storeTranscriptSegment(arbi, queryClient, ref, segment);
-        stored += 1;
-      } catch (err) {
-        failed += 1;
-        console.warn("[calls] a recording piece could not be transcribed", err);
-      }
-    };
-    const sendPieces = async (pieces) => {
-      for (const piece of pieces) {
-        await send({
-          audio: new Blob([floatToWav(piece.samples, EXPORT_SAMPLE_RATE)], { type: "audio/wav" }),
-          segment: nextSegment++,
-          offsetMs: piece.start / EXPORT_SAMPLE_RATE * 1e3
-        });
-      }
-    };
-    for (const part of sortedParts(track)) {
-      let bytes;
-      try {
-        bytes = await fetchPart(arbi, part, key);
-      } catch (err) {
-        failed += 1;
-        console.warn("[calls] a recording part could not be read", err);
-        onProgress?.(++done, total);
-        continue;
-      }
-      let pcm = null;
-      try {
-        pcm = await decode(bytes);
-      } catch (err) {
-        console.warn("[calls] a recording part does not decode; sending it whole", err);
-      }
-      if (pcm) {
-        await sendPieces(cutter.push(part.offset_ms, pcm));
-      } else {
-        await send({
-          audio: new Blob([standalone(bytes)], { type: track.mime_type }),
-          seq: part.seq,
-          offsetMs: part.offset_ms
-        });
-      }
-      onProgress?.(++done, total);
-    }
-    await sendPieces(cutter.finish());
-  }
-  return { stored, failed };
-}
-function useCallsConfig() {
-  const arbi = useArbi();
-  const { data } = useQuery({
-    queryKey: callQueryKeys.config(),
-    queryFn: () => arbi.calls.config(),
-    enabled: arbi.isLoggedIn,
-    staleTime: 5 * 6e4,
-    retry: false
-  });
-  return data;
-}
-function useServerCallsEnabled() {
-  return useCallsConfig()?.enabled === true;
-}
-function useServerCallsExperimental() {
-  return useCallsConfig()?.experimental !== false;
-}
-function useCallTranscriptionAvailable() {
-  return useCallsConfig()?.transcription_available === true;
-}
-function useCall(callExtId) {
-  const arbi = useArbi();
-  return useQuery({
-    queryKey: callQueryKeys.call(callExtId ?? ""),
-    queryFn: () => arbi.calls.get(callExtId),
-    enabled: !!callExtId && arbi.isLoggedIn,
-    staleTime: 6e4,
-    retry: false
-  });
-}
-function useCallRecordings(callExtId, enabled = true) {
-  const arbi = useArbi();
-  return useQuery({
-    queryKey: callQueryKeys.recordings(callExtId ?? ""),
-    queryFn: () => arbi.calls.recording.list(callExtId),
-    enabled: !!callExtId && enabled && arbi.isLoggedIn,
-    retry: false
-  });
-}
-function useCallRecording(callExtId, recordingExtId) {
-  const arbi = useArbi();
-  return useQuery({
-    queryKey: callQueryKeys.recording(callExtId ?? "", recordingExtId ?? ""),
-    queryFn: () => arbi.calls.recording.get(callExtId, recordingExtId),
-    enabled: !!callExtId && !!recordingExtId && arbi.isLoggedIn,
-    retry: false
-  });
-}
-var NO_WINDOWS = [];
-function useRecordingWindows(callExtId, enabled) {
-  const { data } = useCallRecordings(callExtId, enabled);
-  return useMemo(() => data ? recordingWindowsOf(data) : NO_WINDOWS, [data]);
-}
-function useCallInviteLinks(callExtId) {
-  const arbi = useArbi();
-  return useQuery({
-    queryKey: callQueryKeys.inviteLinks(callExtId ?? ""),
-    queryFn: () => arbi.calls.inviteLinks.list(callExtId),
-    enabled: !!callExtId && arbi.isLoggedIn,
-    retry: false
-  });
-}
-function useRecordingActions(call) {
-  const arbi = useArbi();
-  const queryClient = useQueryClient();
-  return useMemo(
-    () => ({
-      refresh: () => void queryClient.invalidateQueries({
-        queryKey: callQueryKeys.recordingsOf(call.external_id)
-      }),
-      open: (recording) => openRecording(arbi, queryClient, call, recording.external_id, recording),
-      transcribe: async (opened, onProgress) => transcribeRecording({
-        arbi,
-        queryClient,
-        callExtId: call.external_id,
-        opened,
-        ref: await meetingRefForCall(arbi, queryClient, call),
-        onProgress
-      })
-    }),
-    [arbi, queryClient, call]
-  );
-}
-function useRevokeCallInviteLink(callExtId) {
-  const arbi = useArbi();
-  const queryClient = useQueryClient();
-  return useCallback(
-    async (inviteExtId) => {
-      await arbi.calls.inviteLinks.revoke(callExtId, inviteExtId);
-      void queryClient.invalidateQueries({ queryKey: callQueryKeys.inviteLinks(callExtId) });
-    },
-    [arbi, queryClient, callExtId]
-  );
-}
-async function postToThread(arbi, conversationExtId, newThreadTitle, content) {
-  const posted = await arbi.conversations.postMessage({
-    content,
-    assistant_mode: "mentioned",
-    ...conversationExtId ? { conversation_ext_id: conversationExtId } : { title: newThreadTitle }
-  });
-  return posted?.conversation_ext_id ?? null;
-}
-function postTranscriptToThread(arbi, params) {
-  return postToThread(
-    arbi,
-    params.conversationExtId,
-    `Transcript: ${params.title?.trim() || "Meeting"}`,
-    formatTranscriptMarkdown({ title: params.title, lines: params.lines })
-  );
-}
-function postRecordingDocsToThread(arbi, params) {
-  const meeting = params.title?.trim() || "Meeting";
-  const content = [
-    `**Recording: ${meeting}**`,
-    "",
-    ...params.docExtIds.map((id) => `- \`${id}\``)
-  ].join("\n");
-  return postToThread(arbi, params.conversationExtId, `Recording: ${meeting}`, content);
-}
-async function saveRecordingFilesToThread(arbi, params) {
-  const workspaceId = params.workspaceExtId;
-  const workspaceKey = await arbi.workspaces.key(workspaceId).catch(() => null);
-  params.onUploading?.();
-  const result = workspaceKey ? await arbi.documents.uploadDirect(
-    workspaceId,
-    workspaceKey,
-    await Promise.all(
-      params.files.map(async (file) => ({
-        name: file.name,
-        data: new Uint8Array(await file.arrayBuffer()),
-        contentType: file.type || documents.mimeFromName(file.name)
-      }))
-    ),
-    { shared: true }
-  ) : await arbi.documents.upload(params.files, { shared: true, workspaceExtId: workspaceId });
-  const docExtIds = result.doc_ext_ids ?? [];
-  const skipped = result.skipped ?? [];
-  if (!docExtIds.length) {
-    throw new Error(`The files were not uploaded${skipped[0] ? `: ${skipped[0].reason}` : ""}`);
-  }
-  return postRecordingDocsToThread(arbi, {
-    conversationExtId: params.conversationExtId,
-    title: params.title,
-    docExtIds
-  });
-}
-function useSaveToThread() {
-  const arbi = useArbi();
-  const queryClient = useQueryClient();
-  return useMemo(() => {
-    const thenRefresh = async (run) => {
-      const result = await run;
-      void invalidateConversationLists(queryClient);
-      return result;
-    };
-    return {
-      transcript: (params) => thenRefresh(postTranscriptToThread(arbi, params)),
-      recording: (params) => thenRefresh(saveRecordingFilesToThread(arbi, params))
-    };
-  }, [arbi, queryClient]);
-}
-function callLink(callExtId, key, linkVersion) {
-  return buildCallLink(window.location.origin, callExtId, key, linkVersion);
-}
-function alreadyInCall(callExtId) {
-  const active = callSession.getState().active;
-  if (!active || active.callExtId === callExtId) return false;
-  notify.warning("You are already in a call. Leave it first.");
-  return true;
-}
-function fail(err, what = "start the call") {
-  console.error(`[calls] failed to ${what}`, err);
-  const message = err instanceof Error ? err.message : "Unknown error";
-  notify.error(`Could not ${what}: ${message}`);
-}
-function callContext(call) {
-  return {
-    chatExtId: call.chat_ext_id ?? null,
-    logConversationExtId: call.log_conversation_ext_id ?? null,
-    meetingConversationExtId: call.meeting_conversation_ext_id ?? null,
-    lockedWorkspaceExtId: call.locked_workspace_ext_id ?? null
-  };
-}
-async function sendInviteLinks(arbi, callExtId, key, linkVersion, invites) {
-  let sent = 0;
-  for (const invite of invites) {
-    try {
-      await arbi.calls.inviteLinks.create(callExtId, {
-        contact_ext_id: invite.contactExtId,
-        link: callLink(callExtId, key, linkVersion)
-      });
-      sent += 1;
-    } catch (err) {
-      fail(err, `invite ${invite.name || "a contact"}`);
-    }
-  }
-  if (sent) notify.success(`Sent ${sent} ${sent === 1 ? "invitation" : "invitations"}`);
-  return sent;
-}
-async function startCall(arbi, opts) {
-  if (alreadyInCall()) return false;
-  try {
-    const {
-      call,
-      key,
-      title,
-      sealedKeys: ringOnJoin
-    } = await arbi.calls.start({ ...opts.context, title: opts.title, invitees: opts.ring });
-    callSession.setActiveCall({
-      callExtId: call.external_id,
-      key,
-      linkVersion: call.link_version,
-      title,
-      isCreator: call.is_creator,
-      ...callContext(call),
-      phase: "prejoin",
-      tokenResponse: null,
-      choices: null,
-      knock: null,
-      ringOnJoin: Object.keys(ringOnJoin).length ? ringOnJoin : null
-    });
-    if (opts.invites?.length) {
-      void sendInviteLinks(arbi, call.external_id, key, call.link_version, opts.invites);
-    }
-    return true;
-  } catch (err) {
-    fail(err);
-    return false;
-  }
-}
-function startThreadCall(arbi, opts) {
-  return startCall(arbi, {
-    context: { threadExtId: opts.threadExtId },
-    title: opts.title,
-    ring: opts.ring
-  });
-}
-function startChatCall(arbi, opts) {
-  return startCall(arbi, {
-    context: { chatExtId: opts.chatExtId },
-    title: opts.title,
-    ring: opts.ring
-  });
-}
-async function startDmCall(arbi, peer) {
-  if (alreadyInCall()) return false;
-  if (!peer.encryption_public_key) {
-    fail(new Error("This person cannot receive encrypted calls"));
-    return false;
-  }
-  let chatExtId;
-  try {
-    chatExtId = (await arbi.chats.openDirect(peer.external_id)).external_id;
-  } catch (err) {
-    fail(err);
-    return false;
-  }
-  return startChatCall(arbi, { chatExtId, title: peer.name ?? null, ring: [peer] });
-}
-function startContactsCall(arbi, opts) {
-  return startCall(arbi, { context: {}, title: opts.title, ring: opts.ring, invites: opts.invites });
-}
-async function openCall(arbi, opts) {
-  if (alreadyInCall(opts.callExtId)) return false;
-  try {
-    const { call, key, title } = await arbi.calls.open(opts.callExtId, opts.key);
-    callSession.setActiveCall({
-      callExtId: call.external_id,
-      key,
-      linkVersion: opts.linkVersion ?? call.link_version,
-      title,
-      isCreator: call.is_creator,
-      ...callContext(call),
-      phase: "prejoin",
-      tokenResponse: null,
-      choices: null,
-      knock: null,
-      ringOnJoin: null,
-      inviteToken: opts.inviteToken ?? null
-    });
-    return true;
-  } catch (err) {
-    fail(err, "open the call");
-    return false;
-  }
-}
-async function acceptRing(arbi, ring) {
-  const current = callSession.getState().active;
-  if (current && current.callExtId !== ring.call_ext_id) callSession.endActiveCall();
-  try {
-    const { key, token, title } = await arbi.calls.answer(ring);
-    callSession.setActiveCall({
-      callExtId: ring.call_ext_id,
-      key,
-      linkVersion: ring.link_version,
-      title: title || ring.caller_name,
-      isCreator: false,
-      chatExtId: ring.chat_ext_id ?? null,
-      logConversationExtId: ring.log_conversation_ext_id ?? null,
-      meetingConversationExtId: ring.meeting_conversation_ext_id ?? null,
-      lockedWorkspaceExtId: ring.context === "thread" ? ring.workspace_ext_id ?? null : null,
-      phase: "connected",
-      tokenResponse: token,
-      choices: DEFAULT_JOIN_CHOICES,
-      knock: null,
-      ringOnJoin: null
-    });
-    return true;
-  } catch (err) {
-    fail(err, "join the call");
-    callSession.removeIncomingCall(ring.call_ext_id);
-    return false;
-  }
-}
-function declineRing(arbi, ring) {
-  callSession.removeIncomingCall(ring.call_ext_id);
-  arbi.calls.decline(ring.call_ext_id).catch((err) => console.warn("[calls] decline failed", err));
-}
-var KNOCK_POLL_MS = 2e3;
-async function waitForAdmission(arbi, callExtId, knock, signal) {
-  for (; ; ) {
-    if (signal.aborted) throw new DOMException("Stopped waiting", "AbortError");
-    await new Promise((resolve) => setTimeout(resolve, KNOCK_POLL_MS));
-    if (signal.aborted) throw new DOMException("Stopped waiting", "AbortError");
-    const state2 = await arbi.calls.pollKnock(callExtId, knock.knock_id);
-    if (state2.status === "admitted" && state2.token) return state2.token;
-    if (state2.status === "denied") throw new CallApiError("The host declined your request.", 403);
-    if (state2.status === "expired") throw new CallApiError("Nobody let you in. Try again.", 410);
-  }
-}
-async function joinFromPreJoin(arbi, choices) {
-  const active = callSession.getState().active;
-  if (!active) return;
-  const { callExtId, linkVersion, inviteToken } = active;
-  const update2 = (patch) => callSession.updateActiveCall(callExtId, patch);
-  try {
-    let tokenResponse;
-    try {
-      tokenResponse = await arbi.calls.token(callExtId, linkVersion, inviteToken);
-    } catch (err) {
-      if (!(err instanceof CallApiError && err.code === "knock_required")) throw err;
-      const knock = await arbi.calls.knock(callExtId, linkVersion);
-      if (knock.status === "admitted" && knock.token) tokenResponse = knock.token;
-      else {
-        const controller = new AbortController();
-        update2({ phase: "knocking", choices, knock: { abort: () => controller.abort() } });
-        tokenResponse = await waitForAdmission(arbi, callExtId, knock, controller.signal);
-      }
-    }
-    if (callSession.getState().active?.callExtId !== callExtId) return;
-    update2({ phase: "connected", tokenResponse, choices, knock: null });
-    const ring = active.ringOnJoin;
-    if (ring && Object.keys(ring).length) {
-      update2({ ringOnJoin: null });
-      await arbi.calls.ring(callExtId, ring, linkVersion).catch((err) => console.warn("[calls] ring failed", err));
-    }
-  } catch (err) {
-    if (err instanceof DOMException && err.name === "AbortError") return;
-    if (err instanceof CallApiError && err.code === "webinar_not_live") {
-      update2({ phase: "webinar-waiting", choices, knock: null });
-      return;
-    }
-    fail(err, "join the call");
-    if (callSession.getState().active?.callExtId === callExtId) {
-      callSession.endActiveCall();
-    }
-  }
-}
-var CALL_WEBINAR_TOPIC = "arbi.webinar";
-var AUDIENCE_CHOICES = { audioEnabled: false, videoEnabled: false };
-var isHand = (h) => !!h && typeof h === "object" && typeof h.identity === "string" && typeof h.raised_at === "string";
-function parseWebinarPacket(payload, fromParticipant) {
-  if (fromParticipant) return null;
-  let raw;
-  try {
-    raw = JSON.parse(new TextDecoder().decode(payload));
-  } catch {
-    return null;
-  }
-  if (!raw || typeof raw !== "object") return null;
-  const p = raw;
-  switch (p.type) {
-    case "state":
-      if (typeof p.live !== "boolean") return null;
-      return {
-        type: "state",
-        live: p.live,
-        live_at: typeof p.live_at === "string" ? p.live_at : null,
-        chat: p.chat === "everyone" ? "everyone" : "panelists"
-      };
-    case "hands":
-      return {
-        type: "hands",
-        hands: Array.isArray(p.hands) ? p.hands.filter(isHand).map((h) => ({ ...h, name: String(h.name ?? "") })) : []
-      };
-    case "questions":
-    case "promoted":
-    case "demoted":
-      return { type: p.type };
-    default:
-      return null;
-  }
-}
-var UNREADABLE = "(This question could not be decrypted.)";
-function sealQuestionText(text, key) {
-  return encryptCallTitle(text, key);
-}
-async function openQuestion(q, key) {
-  const [text, answerText] = await Promise.all([
-    decryptCallTitle(q.body, key),
-    q.answer ? decryptCallTitle(q.answer, key) : Promise.resolve(null)
-  ]);
-  return { ...q, text: text ?? UNREADABLE, answerText };
-}
-function markRejoining(callExtId, on = true) {
-  callSession.updateActiveCall(callExtId, { rejoining: on });
-}
-async function rejoinAsAudience(arbi, callExtId) {
-  if (callSession.getState().active?.callExtId !== callExtId) return;
-  markRejoining(callExtId);
-  try {
-    await joinFromPreJoin(arbi, AUDIENCE_CHOICES);
-  } finally {
-    markRejoining(callExtId, false);
-  }
-}
-
-// src/calls/read-only.ts
-function isWorkspaceGuestOf(workspaces, workspaceExtId, me) {
-  if (!workspaceExtId || !me || !workspaces) return false;
-  const workspace = workspaces.find((w) => w.external_id === workspaceExtId);
-  return workspace?.users?.find((wu) => wu.user.external_id === me)?.role === "guest";
-}
-function useMeetingReadOnly(lockedWorkspaceExtId) {
-  const arbi = useArbi();
-  const me = arbi.isLoggedIn ? arbi.user.identity()?.externalId ?? null : null;
-  const { data: workspaces } = useWorkspaces({
-    enabled: !!lockedWorkspaceExtId && arbi.isLoggedIn
-  });
-  return isWorkspaceGuestOf(
-    workspaces,
-    lockedWorkspaceExtId,
-    me
-  );
-}
-
-// src/calls/gate.ts
-function useCallsEnabled() {
-  const serverEnabled = useServerCallsEnabled();
-  const experimental = useServerCallsExperimental();
-  const switchedOn = useFeature("calls");
-  return serverEnabled && (switchedOn || !experimental);
-}
-function useCanHostCalls() {
-  const callsEnabled = useCallsEnabled();
-  const entitled = useIsEntitled("host_calls");
-  return callsEnabled && entitled;
-}
-function useOpenCallMeetingChat() {
-  const arbi = useArbi();
-  const queryClient = useQueryClient();
-  const open = useArbiHost().calls?.openMeetingChat;
-  return useCallback(
-    async (target) => {
-      try {
-        const ref = await resolveMeetingChat(arbi, queryClient, target);
-        open?.(ref);
-      } catch (err) {
-        console.warn("[calls] could not open the meeting chat", err);
-        notify.error(
-          `Could not open the meeting chat: ${err instanceof Error ? err.message : "unknown error"}`
-        );
-      }
-    },
-    [arbi, queryClient, open]
-  );
-}
-
-export { AUDIENCE_CHOICES, CALL_CAPTION_TOPIC, CALL_CHAT_MAX_CHARS, CALL_CHAT_TOPIC, CALL_MODERATION_TOPIC, CALL_RECORDING_TOPIC, CALL_TRANSCRIPTION_TOPIC, CALL_WEBINAR_TOPIC, CAPTION_MAX_CHARS, COMPOSITE_AUDIO_BITS_PER_SECOND, COMPOSITE_VIDEO_BITS_PER_SECOND, DEFAULT_JOIN_CHOICES, EMPTY_CALL_SESSION, EXPORT_SAMPLE_RATE, HISTORY_LIMIT, LIVE_SEGMENTER, MAX_AVATAR_FILE_BYTES, MUTED_DEDUPE_MS, OFFLINE_MAIL_DB, PLAYBACK_LOOKAHEAD_MS, READ_ONLY_MEETING_TEXT, RECORDING_CHUNK_MS, RECORDING_SEGMENTER, SCOPE_DAYS, SEGMENT_FRAME_MS, SEGMENT_ID_PATTERN, SEGMENT_PRE_ROLL_MS, SHORT_PIECE_MERGE_GAP_MS, SPEAKER_AUDIO_BITS_PER_SECOND, TrackUploader, UPLOAD_ATTEMPTS, UPLOAD_BACKOFF_MS, acceptRing, addConversationToList, allRecordSizes, appendToThread, applyAgentDmStatus, applyCallEvent, applyChatEvent, applyChatMessage, applyChatRead, applyChatUpdated, arbiAccountClient, blind, buildMeetingChatBody, cachedChat, cachedChats, callLink, callMemberKeys, callSession, chatByExtId, chatHasLiveCall, chatLiveCallId, chatTranscriptRef, claimOfflineMail, clearMeetingChatCache, clearTrackUploaders, clockTime, compositeFiles, compositeTrack, conversationKeyForCall, createLocalFeatureStore, createMutedNotifier, createRecordStore, createTrackCutter, cutAtPauses, declineRing, decodeCallChatPacket, decodeCaptionPacket, decodeMono16k, decryptPart, deleteChatMessage, deleteRecords, dropFromThread, encodeCallChatPacket, encodeCaptionPacket, encodeWav, encryptPart, ensureMeetingChat, entitlementRefusal, extensionFor, fetchPart, fileSafe, findConversation, floatToWav, formatTranscriptMarkdown, getMeta, getOfflineMailSettings, getOpenChat, getRecord, hasRecord, hasRecordingTranscript, inOfflineWindow, invalidateCall, invalidateConversationDetails, invalidateConversationLists, isConversationListKey, isConversationShared, isRecordingOver, isRecordingSegmentId, isRetryable, isWorkspaceGuestOf, joinFromPreJoin, knownMeetingChat, loadMeetingHistory, markRejoining, meetingChatRefFrom, meetingRefForCall, mergeChatLines, mutedNoticeFromEvent, mutedNoticeFromPacket, mutedNoticeText, myChatId, newPacketId, newSegmentId, newTrackKey, nextSeqAfter, notifyOfflineMailChange, offlineWindowStart, onCallEvent, onOfflineMailChange, openBytes, openCall, openJson, openQuestion, openRecording, parseWebinarPacket, partKey, partOffsetMs, partsDue, patchConversation, patchConversationList, persistMeetingMessage, persistTranscriptSegment, playheadAt, postRecordingDocsToThread, postTranscriptToThread, putRecord, readLocalFeature, recordingFiles, recordingWindowsOf, recordsInBucket, recordsOfKind, rejoinAsAudience, removeChat, removeConversationFromLists, resetCallSession, resolveMeetingChat, saveRecordingFilesToThread, schedulePart, sealBytes, sealJson, sealQuestionText, serverCallsExperimental, setMeta, setOfflineMailSettings, setOpenChat, sortTranscriptMessages, sortedParts, speakerTracks, speakerWav, splitIntoFiles, standalone, startChatCall, startContactsCall, startDmCall, startThreadCall, startsMediaFile, storeTranscriptSegment, stripSpeakerPrefix, supersedeLiveTranscript, supersededTranscriptLines, threadHasLiveCall, threadLiveCallId, threadTranscriptLines, threadTranscriptRef, threadTranscriptText, timelineDurationMs, timelineOf, toProfileView, touchRecord, trackUploaderFor, transcribeRecording, transcriptPersistRole, transcriptSegmentOf, unwrapTrackKey, upsertChat, useAccountClient, useAvatarCrop, useCall, useCallInviteLinks, useCallRecording, useCallRecordings, useCallSession, useCallTranscriptionAvailable, useCallsConfig, useCallsEnabled, useCanHostCalls, useEntitlements, useFeature, useFeatureCheck, useFeatureSwitch, useInvalidateEntitlements, useIsEntitled, useMeetingReadOnly, useNameEditor, useOpenCallMeetingChat, useProfile, useRecordingActions, useRecordingWindows, useRevokeCallInviteLink, useSaveToThread, useServerCallsEnabled, useServerCallsExperimental, useUpdateProfile, useUpdateUserSettings, useUserSettings, wipeOfflineMail, wrapTrackKey, writeSamples };
-//# sourceMappingURL=chunk-DZKRL5H3.js.map
-//# sourceMappingURL=chunk-DZKRL5H3.js.map