feat(calls): undeafen catch-up toast (#128)

On deafen the participant set is snapshotted; on undeafen it is diffed and,
only if it changed and you were deafened for at least 10 s, one auto-dismissing
toast says 'While you were deafened: Alice, Bob joined · Cole left' (names
capped at 3 + N more). Rides the membership stream that already drives the
join/leave sounds — no new subscriptions; PTT holds don't touch deafen so they
can't trigger it. Verified headless: short deafen → nothing; bob leaves during
an 11 s deafen → 'bob left'; long deafen with no change → nothing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PPmy3tPq869XDW4njjVaKA

src/app/hooks/useCallJoinLeaveSounds.ts

@@ -1,6 +1,7 @@
 import { useCallback, useEffect, useRef } from 'react';
 import { CallMembership } from 'matrix-js-sdk/lib/matrixrtc/CallMembership';
-import { CallEmbed } from '../plugins/call';
+import { useSetAtom } from 'jotai';
+import { CallEmbed, useCallControlState } from '../plugins/call';
 import { useSetting } from '../state/hooks/settings';
 import { settingsAtom } from '../state/settings';
 import { useMatrixClient } from './useMatrixClient';
@@ -8,6 +9,9 @@ import { useCallMembersChange, useCallSession } from './useCall';
 import { useCallJoined } from './useCallEmbed';
 import { playCallJoinSound, playCallLeaveSound } from '../utils/callSounds';
 import { createCallSoundDebouncer } from '../utils/callSoundDebounce';
+import { toastQueueAtom } from '../state/toast';
+import { DEAFEN_CATCHUP_MIN_MS, deafenCatchUpText } from '../utils/deafenCatchUp';
+import { getMemberName } from '../utils/room';
 
 const membershipKey = (m: CallMembership): string => `${m.sender}|${m.deviceId}`;
 const userOfKey = (key: string): string => key.slice(0, key.indexOf('|'));
@@ -30,6 +34,40 @@ export function useCallJoinLeaveSounds(embed: CallEmbed): void {
   const styleRef = useRef(style);
   styleRef.current = style;
 
+  // [Gitea #128] Undeafen catch-up: snapshot who is here when you deafen, diff
+  // when you undeafen, one toast if it changed and you were deafened ≥ 10 s.
+  // Rides the same membership stream as the sounds — no new subscriptions.
+  const { sound } = useCallControlState(embed.control);
+  const setToast = useSetAtom(toastQueueAtom);
+  const usersNow = useRef<Set<string>>(new Set());
+  const deafenedAt = useRef<{ at: number; users: Set<string> } | null>(null);
+  useEffect(() => {
+    if (!joined) {
+      deafenedAt.current = null;
+      return;
+    }
+    if (!sound) {
+      if (!deafenedAt.current)
+        deafenedAt.current = { at: Date.now(), users: new Set(usersNow.current) };
+      return;
+    }
+    const snap = deafenedAt.current;
+    deafenedAt.current = null;
+    if (!snap || Date.now() - snap.at < DEAFEN_CATCHUP_MIN_MS) return;
+    const text = deafenCatchUpText(snap.users, usersNow.current, (u) =>
+      getMemberName(embed.room, u),
+    );
+    if (text) {
+      setToast({
+        id: `deafen-catchup-${Date.now()}`,
+        displayName: 'Lotus Chat',
+        body: text,
+        roomName: embed.room.name ?? 'Voice call',
+        roomId: embed.roomId,
+      });
+    }
+  }, [sound, joined, embed, setToast]);
+
   // One debouncer per joined call, so pending leave cues die with the call.
   const debouncerRef = useRef<ReturnType<typeof createCallSoundDebouncer> | null>(null);
   useEffect(() => {
@@ -62,6 +100,9 @@ export function useCallJoinLeaveSounds(embed: CallEmbed): void {
         const next = new Set(members.map(membershipKey));
         const prev = prevKeysRef.current ?? next;
         prevKeysRef.current = next;
+        usersNow.current = new Set(
+          Array.from(next, userOfKey).filter((u) => u !== mx.getSafeUserId()),
+        );
 
         const debouncer = debouncerRef.current;
         if (!joined || style === 'off' || !debouncer) return;