@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/dist/chunk-JU2FAPBI.js

@@ -0,0 +1,609 @@
+import { createOutbox, upsertMessages, currentActivity, mergeThread, throttle, firstUnreadId } from './chunk-A4YJX7KT.js';
+import { sendBytes, attachmentKindFor, randomId } from './chunk-GBJ3YI4E.js';
+import { useQueryClient, useQuery, useQueries } from '@tanstack/react-query';
+import { createContext, useState, useRef, useMemo, useEffect, useContext, useCallback } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var chatKeys = {
+  all: ["genesis-chat"],
+  inbox: (opts) => ["genesis-chat", "inbox", opts ?? {}],
+  unread: () => ["genesis-chat", "unread"],
+  conversation: (id) => ["genesis-chat", "conversation", id],
+  members: (id) => ["genesis-chat", "members", id],
+  role: (id) => ["genesis-chat", "role", id],
+  pins: (id) => ["genesis-chat", "pins", id],
+  files: (paths) => ["genesis-chat", "files", [...paths].sort()],
+  /** Under the conversation's key, so its `conversation` hint (set_topic broadcasts one) refreshes them. */
+  topics: (id) => ["genesis-chat", "conversation", id, "topics"],
+  scheduled: (conversationId) => ["genesis-chat", "scheduled", conversationId ?? null],
+  availability: (conversationId) => ["genesis-chat", "conversation", conversationId, "availability"],
+  myAvailability: () => ["genesis-chat", "my-availability"],
+  search: (query, conversationId) => ["genesis-chat", "search", conversationId ?? null, query],
+  previews: (messageIds) => ["genesis-chat", "previews", [...messageIds].sort()],
+  /** One message's link previews (useLinkPreviews keeps one query per message). */
+  preview: (messageId) => ["genesis-chat", "preview", messageId]
+};
+var CATCH_UP_PAGE = 200;
+var CATCH_UP_MAX_PAGES = 10;
+function isMessagesData(v) {
+  return typeof v === "object" && v !== null && Array.isArray(v.messages) && "hasEarlier" in v;
+}
+function upsertInto(prev, incoming) {
+  return isMessagesData(prev) ? { ...prev, messages: upsertMessages(prev.messages, incoming) } : void 0;
+}
+function belongsTo(key, m) {
+  return key[0] === "genesis-chat" && key[1] === "conversation" && key[2] === m.conversationId && key[3] === "messages" && (key[4] ?? null) === (m.threadRootId ?? null) && (key[5] == null || key[5] === m.topic);
+}
+function hostedUploadFrom(videoUpload, options = {}) {
+  return async (conversationId, file, { signal, onProgress, resume }) => {
+    const minted = resume?.url ? { url: resume.url, providerId: resume.providerId, provider: resume.provider } : await videoUpload.create(conversationId);
+    const done = (async () => {
+      const body = typeof file.data === "string" ? await (options.readFile ?? (() => Promise.reject(new Error("This file can't be read on this device"))))(file.data) : file.data;
+      await sendBytes(minted.url, body, { method: "PUT", headers: { "Content-Type": file.contentType }, signal, onProgress, fetch: options.fetch });
+    })();
+    return { provider: minted.provider, providerId: minted.providerId, status: "pending", url: minted.url, done };
+  };
+}
+var ChatContext = createContext(null);
+function ChatProvider({
+  client,
+  userId,
+  outboxStore,
+  readFile,
+  upload,
+  hostedUpload,
+  newId,
+  persistFile,
+  releasePreview,
+  loadPeople,
+  videoUpload,
+  attachmentKinds,
+  children
+}) {
+  const queryClient = useQueryClient();
+  const [queue, setQueue] = useState([]);
+  const listeners = useRef(/* @__PURE__ */ new Set());
+  const live = useRef({ readFile, upload, hostedUpload, videoUpload, persistFile });
+  live.current = { readFile, upload, hostedUpload, videoUpload, persistFile };
+  const outbox = useMemo(
+    () => createOutbox({
+      client,
+      userId,
+      store: outboxStore,
+      readFile: readFile && ((uri) => (live.current.readFile ?? readFile)(uri)),
+      upload: upload && ((...args) => (live.current.upload ?? upload)(...args)),
+      hostedUpload: hostedUpload || videoUpload ? (...args) => {
+        const now = live.current;
+        const video = now.videoUpload ?? videoUpload;
+        const send = now.hostedUpload ?? (video ? hostedUploadFrom(video, { readFile: now.readFile ?? readFile }) : hostedUpload);
+        return send(...args);
+      } : void 0,
+      newId,
+      persistFile: persistFile && ((file) => (live.current.persistFile ?? persistFile)(file)),
+      releasePreview,
+      onChange: setQueue,
+      onSent: (message) => {
+        queryClient.setQueriesData(
+          { predicate: (q) => belongsTo(q.queryKey, message) },
+          (prev) => upsertInto(prev, [message]) ?? prev
+        );
+        void queryClient.invalidateQueries({ queryKey: ["genesis-chat", "scheduled"] });
+        void queryClient.invalidateQueries({ queryKey: ["genesis-chat", "inbox"] });
+      }
+    }),
+    // A new person or client is a new outbox.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [client, userId]
+  );
+  useEffect(() => {
+    void outbox.load().then(() => outbox.retryAll()).catch(() => void 0);
+    const online = () => void outbox.retryAll().catch(() => void 0);
+    const target = typeof window !== "undefined" && typeof window.addEventListener === "function" ? window : null;
+    target?.addEventListener("online", online);
+    const sub = client.subscribeInbox(userId, (signal) => {
+      void queryClient.invalidateQueries({ queryKey: ["genesis-chat", "inbox"] });
+      void queryClient.invalidateQueries({ queryKey: chatKeys.unread() });
+      for (const l of listeners.current) l(signal);
+    });
+    return () => {
+      sub.unsubscribe();
+      target?.removeEventListener("online", online);
+    };
+  }, [client, userId, outbox, queryClient]);
+  const value = useMemo(
+    () => ({
+      client,
+      userId,
+      outbox,
+      queue,
+      loadPeople,
+      videoUpload,
+      attachmentKinds,
+      retryAll: () => outbox.retryAll(),
+      clearOutbox: () => outbox.clear(),
+      onInbox: (l) => {
+        listeners.current.add(l);
+        return () => listeners.current.delete(l);
+      }
+    }),
+    [client, userId, outbox, queue, loadPeople, videoUpload, attachmentKinds]
+  );
+  return /* @__PURE__ */ jsx(ChatContext.Provider, { value, children });
+}
+function useChat() {
+  const ctx = useContext(ChatContext);
+  if (!ctx) throw new Error("Chat hooks need a <ChatProvider> above them.");
+  return ctx;
+}
+function useInbox(opts = {}) {
+  const { client } = useChat();
+  const query = useQuery({ queryKey: chatKeys.inbox(opts), queryFn: () => client.inbox(opts), staleTime: 15e3 });
+  return { items: query.data ?? [], isLoading: query.isLoading, error: query.error, refetch: query.refetch };
+}
+function useUnreadTotal(opts = {}) {
+  const { client } = useChat();
+  return useQuery({ queryKey: [...chatKeys.unread(), opts.excludeKinds ?? []], queryFn: () => client.unreadTotal(opts), staleTime: 15e3 }).data ?? 0;
+}
+function useConversation(conversationId, opts = {}) {
+  const { client, userId, outbox, queue } = useChat();
+  const queryClient = useQueryClient();
+  const id = conversationId ?? "";
+  const enabled = Boolean(conversationId);
+  const pageSize = opts.pageSize ?? 50;
+  const messagesKey = useMemo(
+    () => [...chatKeys.conversation(id), "messages", opts.threadRootId ?? null, opts.topic ?? null],
+    [id, opts.threadRootId, opts.topic]
+  );
+  const conversation = useQuery({ queryKey: chatKeys.conversation(id), queryFn: () => client.conversation(id), enabled });
+  const members = useQuery({ queryKey: chatKeys.members(id), queryFn: () => client.members(id), enabled, staleTime: 6e4, refetchOnMount: "always" });
+  const kindRules = useQuery({
+    queryKey: ["genesis-chat", "kind", conversation.data?.kind ?? ""],
+    queryFn: () => client.kind(conversation.data.kind),
+    enabled: Boolean(conversation.data?.kind),
+    staleTime: 10 * 6e4
+  });
+  const access = useQuery({
+    queryKey: chatKeys.role(id),
+    queryFn: async () => ({ role: await client.myRole(id), canPost: await client.canPost(id) }),
+    enabled,
+    staleTime: 6e4
+  });
+  const [loadingEarlier, setLoadingEarlier] = useState(false);
+  const fetchPage = useCallback(
+    () => client.messages(id, { limit: pageSize, threadRootId: opts.threadRootId, topic: opts.topic }),
+    [client, id, pageSize, opts.threadRootId, opts.topic]
+  );
+  const messages = useQuery({ queryKey: messagesKey, queryFn: fetchPage, enabled, staleTime: Infinity });
+  const hasEarlier = messages.data?.hasEarlier ?? false;
+  const [readWhenOpened, setReadWhenOpened] = useState(null);
+  const merge = useCallback(
+    (incoming, hasEarlierNow) => queryClient.setQueryData(messagesKey, (prev) => {
+      const base = prev ?? { messages: [], hasEarlier: false };
+      return { messages: upsertMessages(base.messages, incoming), hasEarlier: hasEarlierNow ?? base.hasEarlier };
+    }),
+    [queryClient, messagesKey]
+  );
+  const catchUp = useCallback(async () => {
+    const current = queryClient.getQueryData(messagesKey) ?? await queryClient.ensureQueryData({ queryKey: messagesKey, queryFn: fetchPage });
+    const list2 = current.messages;
+    let after = list2.length ? list2[list2.length - 1].seq : 0;
+    for (let pages = 0; ; ) {
+      const page = await client.messages(id, { afterSeq: after, limit: CATCH_UP_PAGE, threadRootId: opts.threadRootId, topic: opts.topic });
+      if (page.messages.length) merge(page.messages);
+      if (page.messages.length < CATCH_UP_PAGE) return;
+      after = Math.max(after, ...page.messages.map((m) => m.seq));
+      if (++pages >= CATCH_UP_MAX_PAGES) break;
+    }
+    const newest = await fetchPage();
+    queryClient.setQueryData(messagesKey, { messages: newest.messages, hasEarlier: true });
+  }, [client, fetchPage, id, merge, messagesKey, opts.threadRootId, opts.topic, queryClient]);
+  const [activity, setActivity] = useState([]);
+  const channel = useRef(null);
+  useEffect(() => {
+    if (!enabled) return;
+    const fetchOne = async (messageId) => {
+      const m = await client.message(messageId);
+      if (!m) return;
+      const belongs = opts.threadRootId ? m.threadRootId === opts.threadRootId : m.threadRootId === null;
+      if (belongs && (!opts.topic || m.topic === opts.topic)) merge([m]);
+      if (m.threadRootId && !opts.threadRootId) {
+        const root = await client.message(m.threadRootId);
+        if (root) merge([root]);
+      }
+    };
+    channel.current = client.subscribeConversation(id, userId, {
+      onSignal: (s) => {
+        if (s.type === "message") void fetchOne(s.id);
+        else if (s.type === "reaction") void fetchOne(s.messageId);
+        else if (s.type === "members") {
+          void queryClient.invalidateQueries({ queryKey: chatKeys.members(id) });
+          void queryClient.invalidateQueries({ queryKey: chatKeys.role(id) });
+        } else if (s.type === "conversation") {
+          void queryClient.invalidateQueries({ queryKey: chatKeys.conversation(id), exact: true });
+          void queryClient.invalidateQueries({ queryKey: chatKeys.topics(id) });
+          void queryClient.invalidateQueries({ queryKey: chatKeys.pins(id) });
+        }
+      },
+      onActivity: (a) => setActivity((prev) => currentActivity([...prev, a])),
+      onJoin: () => void catchUp().catch(() => void 0)
+    });
+    return () => {
+      channel.current?.unsubscribe();
+      channel.current = null;
+    };
+  }, [client, enabled, id, userId, merge, catchUp, queryClient, opts.threadRootId, opts.topic]);
+  useEffect(() => {
+    if (activity.length === 0) return;
+    const t = setTimeout(() => setActivity((prev) => currentActivity(prev)), 2e3);
+    return () => clearTimeout(t);
+  }, [activity]);
+  const list = useMemo(() => messages.data?.messages ?? [], [messages.data]);
+  const latestSeq = list.length ? list[list.length - 1].seq : 0;
+  const myLastRead = members.isFetchedAfterMount ? members.data?.find((m) => m.userId === userId)?.lastReadSeq : void 0;
+  useEffect(() => {
+    if (readWhenOpened === null && myLastRead !== void 0) setReadWhenOpened(myLastRead);
+  }, [myLastRead, readWhenOpened]);
+  const markRead = useCallback(async () => {
+    if (!enabled || latestSeq === 0) return;
+    await client.markRead(id, latestSeq);
+    void queryClient.invalidateQueries({ queryKey: ["genesis-chat", "inbox"] });
+    void queryClient.invalidateQueries({ queryKey: chatKeys.unread() });
+  }, [client, enabled, id, latestSeq, queryClient]);
+  const shouldMark = opts.markRead !== false && !opts.threadRootId && !opts.topic;
+  useEffect(() => {
+    if (shouldMark && latestSeq > 0) void markRead().catch(() => void 0);
+  }, [shouldMark, latestSeq, markRead]);
+  const refetchConversation = useCallback(
+    () => Promise.all([
+      // The conversation and what hangs off it (topics, availability), never its message lists:
+      // a refetch would replace loaded history and merged live messages with one fresh page.
+      queryClient.refetchQueries({ queryKey: chatKeys.conversation(id), predicate: (q) => q.queryKey[3] !== "messages" }),
+      queryClient.refetchQueries({ queryKey: chatKeys.members(id) }),
+      queryClient.refetchQueries({ queryKey: chatKeys.role(id) }),
+      queryClient.refetchQueries({ queryKey: chatKeys.pins(id) }),
+      queryClient.refetchQueries({ queryKey: ["genesis-chat", "kind"] })
+    ]).then(() => void 0),
+    [queryClient, id]
+  );
+  const loadEarlier = useCallback(async () => {
+    const first = list[0];
+    if (!first || loadingEarlier) return;
+    setLoadingEarlier(true);
+    try {
+      const page = await client.messages(id, { beforeSeq: first.seq, limit: pageSize, threadRootId: opts.threadRootId, topic: opts.topic });
+      merge(page.messages, page.hasEarlier);
+    } finally {
+      setLoadingEarlier(false);
+    }
+  }, [client, id, list, loadingEarlier, merge, opts.threadRootId, opts.topic, pageSize]);
+  const loadUntil = useCallback(
+    async (seq) => {
+      let current = queryClient.getQueryData(messagesKey);
+      for (let guard = 0; guard < 20 && current; guard++) {
+        const first = current.messages[0];
+        if (!first || first.seq <= seq || !current.hasEarlier) break;
+        const page = await client.messages(id, {
+          beforeSeq: first.seq,
+          limit: Math.min(200, first.seq - seq + 10),
+          threadRootId: opts.threadRootId,
+          topic: opts.topic
+        });
+        merge(page.messages, page.hasEarlier);
+        current = queryClient.getQueryData(messagesKey);
+      }
+      return Boolean(current?.messages.some((m) => m.seq === seq));
+    },
+    [client, id, merge, messagesKey, opts.threadRootId, opts.topic, queryClient]
+  );
+  const pending = useMemo(
+    () => queue.filter(
+      (q) => q.input.conversationId === id && (q.input.threadRootId ?? null) === (opts.threadRootId ?? null) && (!opts.topic || q.input.topic === opts.topic)
+    ).map((q) => ({ ...q, files: q.pendingFiles })),
+    [queue, id, opts.threadRootId, opts.topic]
+  );
+  const items = useMemo(() => mergeThread(list, pending), [list, pending]);
+  const signalTyping = useMemo(() => throttle(() => channel.current?.signal("typing")), []);
+  const signalRecording = useMemo(
+    () => throttle(() => channel.current?.signal("recording-voice")),
+    []
+  );
+  const signalRecordingVideo = useMemo(() => throttle(() => channel.current?.signal("recording-video")), []);
+  const send = useCallback(
+    (input, files = []) => outbox.send({ ...input, conversationId: id, threadRootId: input.threadRootId ?? opts.threadRootId, topic: input.topic ?? opts.topic }, files),
+    [outbox, id, opts.threadRootId, opts.topic]
+  );
+  return {
+    conversation: conversation.data ?? null,
+    members: members.data ?? [],
+    role: access.data?.role ?? null,
+    canPost: access.data?.canPost ?? false,
+    /** Your role and posting rights are still loading: show the composer as waiting, not refused. */
+    accessLoading: enabled && access.isLoading,
+    /** The conversation itself is still loading (it settles to `null` when you can't see it). */
+    conversationLoading: conversation.isLoading,
+    /** Your role couldn't be loaded (offline): offer `refetchAccess`, don't say "can't post". */
+    accessError: access.error ?? null,
+    /** Retries everything this conversation loads (role, members, the conversation, topics, availability, pins), not only access. */
+    refetchAccess: refetchConversation,
+    /** Same as refetchAccess: every per-conversation lookup again, for a Retry after being offline. */
+    refetchConversation,
+    /** The kind's rules (max members, threads, who posts). */
+    kind: kindRules.data ?? null,
+    /** May you pin here: owners and admins, or anyone in a two-person conversation. */
+    canPin: access.data?.role === "owner" || access.data?.role === "admin" || access.data?.role === "member" && kindRules.data?.maxMembers === 2,
+    /** Gives a message whose files were lost on a relaunch its files again. */
+    reattach: outbox.reattach,
+    items,
+    messages: list,
+    isLoading: messages.isLoading || conversation.isLoading,
+    error: messages.error ?? conversation.error,
+    hasEarlier,
+    loadingEarlier,
+    loadEarlier,
+    loadUntil,
+    /** Where to draw the "New" line, from what you had read when it opened. */
+    firstUnreadId: readWhenOpened === null ? null : firstUnreadId(list, readWhenOpened, userId),
+    activity: currentActivity(activity),
+    signalTyping,
+    signalRecording,
+    /** Tells the others you are recording a video (throttled). */
+    signalRecordingVideo,
+    markRead,
+    send,
+    retry: outbox.retry,
+    discard: outbox.discard,
+    refetch: catchUp
+  };
+}
+function useMessageActions() {
+  const { client } = useChat();
+  const queryClient = useQueryClient();
+  return useMemo(() => {
+    const refresh = async (conversationId, messageId) => {
+      const m = await client.message(messageId);
+      queryClient.setQueriesData(
+        { queryKey: chatKeys.conversation(conversationId) },
+        (prev) => m ? upsertInto(prev, [m]) ?? prev : prev
+      );
+    };
+    return {
+      edit: async (m, body, mentions = []) => {
+        await client.edit(m.id, body, mentions);
+        await refresh(m.conversationId, m.id);
+      },
+      remove: async (m) => {
+        await client.remove(m.id);
+        await refresh(m.conversationId, m.id);
+      },
+      react: async (m, emoji, on) => {
+        await client.react(m.id, emoji, on);
+        await refresh(m.conversationId, m.id);
+      },
+      pin: async (m, on) => {
+        await client.pin(m.id, on);
+        void queryClient.invalidateQueries({ queryKey: chatKeys.pins(m.conversationId) });
+      },
+      save: (m, on, note) => client.save(m.id, on, note),
+      report: (m, reason, note) => client.report(m.id, reason, note)
+    };
+  }, [client, queryClient]);
+}
+function usePeople(userIds) {
+  const { loadPeople } = useChat();
+  const ids = useMemo(() => [...new Set(userIds.filter((x) => Boolean(x)))].sort(), [userIds]);
+  return useQuery({
+    queryKey: ["genesis-chat", "people", ids],
+    queryFn: () => loadPeople(ids),
+    enabled: Boolean(loadPeople) && ids.length > 0,
+    staleTime: 5 * 6e4
+  }).data ?? {};
+}
+function usePerson(userId) {
+  const people = usePeople(useMemo(() => [userId], [userId]));
+  return userId ? people[userId] ?? null : null;
+}
+function usePins(conversationId) {
+  const { client } = useChat();
+  return useQuery({ queryKey: chatKeys.pins(conversationId ?? ""), queryFn: () => client.pins(conversationId), enabled: Boolean(conversationId) }).data ?? [];
+}
+function useFileUrls(paths) {
+  const { client } = useChat();
+  const list = useMemo(() => [...new Set(paths.filter((p) => Boolean(p)))], [paths]);
+  return useQuery({ queryKey: chatKeys.files(list), queryFn: () => client.fileUrls(list), enabled: list.length > 0, staleTime: 50 * 6e4 }).data ?? {};
+}
+function useStartConversation() {
+  const { client } = useChat();
+  const queryClient = useQueryClient();
+  return useCallback(
+    async (kind, memberIds, opts) => {
+      const id = await client.startConversation(kind, memberIds, opts);
+      void queryClient.invalidateQueries({ queryKey: ["genesis-chat", "inbox"] });
+      return id;
+    },
+    [client, queryClient]
+  );
+}
+function useTopics(conversationId) {
+  const { client } = useChat();
+  const queryClient = useQueryClient();
+  const id = conversationId ?? "";
+  const query = useQuery({ queryKey: chatKeys.topics(id), queryFn: () => client.topics(id), enabled: Boolean(conversationId), staleTime: 6e4 });
+  const setTopic = useCallback(
+    async (topic, input = {}) => {
+      await client.setTopic(id, topic, input);
+      await queryClient.invalidateQueries({ queryKey: chatKeys.topics(id) });
+    },
+    [client, id, queryClient]
+  );
+  const topics = query.data ?? [];
+  return { topics, isLoading: query.isLoading, error: query.error, setTopic, refetch: query.refetch };
+}
+function useScheduled(conversationId, opts = {}) {
+  const { client, outbox } = useChat();
+  const queryClient = useQueryClient();
+  const query = useQuery({
+    queryKey: chatKeys.scheduled(conversationId),
+    queryFn: () => client.scheduled(conversationId ?? void 0),
+    enabled: opts.enabled ?? true,
+    staleTime: 3e4
+  });
+  const refresh = useCallback(() => queryClient.invalidateQueries({ queryKey: ["genesis-chat", "scheduled"] }), [queryClient]);
+  const schedule = useCallback(
+    async (input, files = []) => {
+      const attachments = [...input.attachments ?? []];
+      for (const f of files) {
+        const path = await outbox.uploadFile(input.conversationId, f);
+        attachments.push({ ...f.meta, kind: f.meta?.kind ?? attachmentKindFor(f.contentType), path, name: f.meta?.name ?? f.name, mime: f.contentType });
+      }
+      const id = await client.schedule({ ...input, clientId: input.clientId ?? randomId(), attachments });
+      await refresh();
+      return id;
+    },
+    [client, outbox, refresh]
+  );
+  const cancel = useCallback(
+    async (id) => {
+      queryClient.setQueriesData({ queryKey: ["genesis-chat", "scheduled"] }, (prev) => Array.isArray(prev) ? prev.filter((s) => s.id !== id) : prev);
+      try {
+        await client.cancelScheduled(id);
+      } finally {
+        await refresh();
+      }
+    },
+    [client, queryClient, refresh]
+  );
+  const items = query.data ?? [];
+  return { items, isLoading: query.isLoading, error: query.error, schedule, cancel, refetch: query.refetch };
+}
+function useAvailability(conversationId) {
+  const { client, userId } = useChat();
+  const queryClient = useQueryClient();
+  const mine = useQuery({ queryKey: chatKeys.myAvailability(), queryFn: () => client.myAvailability(), staleTime: 5 * 6e4 });
+  const members = useQuery({
+    queryKey: chatKeys.availability(conversationId ?? ""),
+    queryFn: () => client.availabilityFor(conversationId),
+    enabled: Boolean(conversationId),
+    staleTime: 5 * 6e4
+  });
+  const setMine = useCallback(
+    async (input) => {
+      await client.setAvailability(input);
+      await queryClient.invalidateQueries({ queryKey: chatKeys.myAvailability() });
+      await queryClient.invalidateQueries({ predicate: (q) => q.queryKey[0] === "genesis-chat" && q.queryKey[3] === "availability" });
+    },
+    [client, queryClient]
+  );
+  const list = members.data ?? [];
+  const forUser = useCallback((id) => list.find((a) => a.userId === id) ?? null, [list]);
+  return {
+    mine: mine.data ?? null,
+    mineLoading: mine.isLoading,
+    setMine,
+    members: list,
+    /** Everyone else's, without yours. */
+    others: list.filter((a) => a.userId !== userId),
+    forUser,
+    isLoading: mine.isLoading || Boolean(conversationId) && members.isLoading
+  };
+}
+function useBroadcast() {
+  const { client } = useChat();
+  const queryClient = useQueryClient();
+  const [sending, setSending] = useState(false);
+  const send = useCallback(
+    async (conversationIds, body, opts = {}) => {
+      setSending(true);
+      try {
+        const ids = await client.broadcast(conversationIds, opts.clientId ?? randomId(), body, { silent: opts.silent });
+        void queryClient.invalidateQueries({ queryKey: ["genesis-chat", "inbox"] });
+        return ids;
+      } finally {
+        setSending(false);
+      }
+    },
+    [client, queryClient]
+  );
+  return { send, sending };
+}
+function useDebouncedValue(value, ms) {
+  const [v, setV] = useState(value);
+  useEffect(() => {
+    if (ms <= 0) {
+      setV(value);
+      return;
+    }
+    const t = setTimeout(() => setV(value), ms);
+    return () => clearTimeout(t);
+  }, [value, ms]);
+  return ms <= 0 ? value : v;
+}
+function useSearch(query, opts = {}) {
+  const { client } = useChat();
+  const q = useDebouncedValue(query.trim(), opts.debounceMs ?? 250);
+  const enabled = q.length >= 2;
+  const result = useQuery({
+    queryKey: chatKeys.search(q, opts.conversationId),
+    queryFn: () => client.search(q, opts.conversationId ?? null, { limit: opts.limit }),
+    enabled,
+    staleTime: 3e4
+  });
+  const hits = enabled ? result.data ?? [] : [];
+  return {
+    hits,
+    /** The query the hits are for. */
+    query: q,
+    /** Typing, or fetching: results are on their way. */
+    isSearching: query.trim() !== q || enabled && result.isFetching,
+    error: result.error
+  };
+}
+var LINK_PREVIEW_CONCURRENCY = 4;
+var previewGates = /* @__PURE__ */ new WeakMap();
+function gate(max) {
+  let active = 0;
+  const waiting = [];
+  return async (task) => {
+    if (active >= max) await new Promise((r) => waiting.push(r));
+    active += 1;
+    try {
+      return await task();
+    } finally {
+      active -= 1;
+      waiting.shift()?.();
+    }
+  };
+}
+function useLinkPreviews(messageIds) {
+  const { client } = useChat();
+  const list = useMemo(() => [...new Set(messageIds.filter((u) => Boolean(u)))].sort(), [messageIds]);
+  let run = previewGates.get(client);
+  if (!run) {
+    run = gate(LINK_PREVIEW_CONCURRENCY);
+    previewGates.set(client, run);
+  }
+  const limited = run;
+  const combine = useCallback(
+    (results) => {
+      let out = null;
+      results.forEach((r, i) => {
+        if (r.data) (out ??= {})[list[i]] = r.data;
+      });
+      return out ?? EMPTY_PREVIEWS;
+    },
+    [list]
+  );
+  return useQueries({
+    queries: list.map((id) => ({
+      queryKey: chatKeys.preview(id),
+      queryFn: () => limited(async () => (await client.linkPreviewsFor([id]))[id] ?? []),
+      staleTime: 6e4,
+      refetchInterval: (q) => !q.state.data?.length && q.state.dataUpdateCount < 4 ? 5e3 : false
+    })),
+    combine
+  });
+}
+var EMPTY_PREVIEWS = {};
+
+export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, ChatProvider, LINK_PREVIEW_CONCURRENCY, belongsTo, chatKeys, hostedUploadFrom, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal };
+//# sourceMappingURL=chunk-JU2FAPBI.js.map
+//# sourceMappingURL=chunk-JU2FAPBI.js.map