fix(rooms): "Rename for me" names in Ctrl+K, forward/share pickers and notifications (#336)

The personal room name (io.lotus.room_names) was only used by the
sidebar, header, intro and call bar; the quick switcher couldn't find a
room by it ("No match found") and showed the server name, as did the
forward/share pickers, toasts, OS notifications and reminders.

useRoomMeta gains useLocalRoomNames() / getLocalRoomName(); the quick
switcher matches both names and shows the personal one, the forward and
share pickers show and filter by it, and message/reminder notifications
use it for the room title.

Verified headless with general renamed to "Zebra Lounge": Ctrl+K "Zebra"
and "general" both list "Zebra Lounge"; the forward picker filtered by
"zebra" lists "Zebra Lounge".

Not covered here (follow-up): message-search result headers, the inbox
notifications page and the threads list still use the server name.

Refs #336

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

src/app/features/room/message/ForwardMessageDialog.tsx

@@ -48,6 +48,7 @@ import {
   addRecentForwardTarget,
 } from '../../../state/recentForwardTargets';
 import { buildForwardContent, buildPlaintextAttachmentContent } from './forwardContent';
+import { useLocalRoomNames } from '../../../hooks/useRoomMeta';
 
 type RoomRowProps = {
   room: Room;
@@ -58,6 +59,7 @@ type RoomRowProps = {
   sending: boolean;
 };
 function RoomRow({ room, dm, useAuthentication, selected, onToggle, sending }: RoomRowProps) {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
   const avatarMxc = room.getMxcAvatarUrl();
   const avatarUrl = avatarMxc
@@ -97,7 +99,7 @@ function RoomRow({ room, dm, useAuthentication, selected, onToggle, sending }: R
     >
       <Box direction="Column">
         <Text size="T300" truncate>
-          {room.name}
+          {localNames[room.roomId] ?? room.name}
         </Text>
         {dm && (
           <Text size="T200" priority="300" truncate>
@@ -212,6 +214,7 @@ function RecentChip({
   onToggle: () => void;
   sending: boolean;
 }) {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
   const avatarMxc = room.getMxcAvatarUrl();
   const avatarUrl = avatarMxc
@@ -240,7 +243,7 @@ function RecentChip({
       }
     >
       <Text size="B300" truncate style={{ maxWidth: toRem(120) }}>
-        {room.name}
+        {localNames[room.roomId] ?? room.name}
       </Text>
     </Chip>
   );
@@ -252,6 +255,7 @@ type Props = {
 };
 
 export function ForwardMessageDialog({ mEvent, onClose }: Props) {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
   const modalStyle = useModalStyle(400);
   const directs = useAtomValue(mDirectAtom);
@@ -296,8 +300,10 @@ export function ForwardMessageDialog({ mEvent, onClose }: Props) {
   const filtered = useMemo(() => {
     if (!query) return allRooms;
     const q = query.toLowerCase();
-    return allRooms.filter((r) => r.name.toLowerCase().includes(q));
+    return allRooms.filter((r) =>
-  }, [allRooms, query]);
+      [r.name, localNames[r.roomId]].some((nm) => nm?.toLowerCase().includes(q)),
+    );
+  }, [allRooms, query, localNames]);
 
   // Resolve recent target ids to still-joined rooms (drop ones left/gone).
   const recentRooms = useMemo(

src/app/features/search/Search.tsx

@@ -37,6 +37,7 @@ import {
   useAsyncSearch,
   UseAsyncSearchOptions,
 } from '../../hooks/useAsyncSearch';
+import { useLocalRoomNames } from '../../hooks/useRoomMeta';
 import { useAllJoinedRoomsSet, useGetRoom } from '../../hooks/useGetRoom';
 import { RoomAvatar, RoomIcon } from '../../components/room-avatar';
 import {
@@ -157,17 +158,20 @@ export function Search({ requestClose }: SearchProps) {
   const topActiveRooms = useTopActiveRooms(searchRoomType, rooms, directs, spaces);
   const targetRooms = useSearchTargetRooms(searchRoomType, rooms, directs, spaces);
 
+  const localNames = useLocalRoomNames();
   const getTargetStr: SearchItemStrGetter<string> = useCallback(
     (roomId: string) => {
       const roomName = getRoom(roomId)?.name ?? roomId;
+      // [Gitea #336] Match the user's own "Rename for me" name as well.
+      const names = localNames[roomId] ? [localNames[roomId], roomName] : [roomName];
       if (mDirects.has(roomId)) {
         const targetUserId = getDmUserId(roomId, getRoom, mx.getSafeUserId());
         const targetUsername = targetUserId && getMxIdLocalPart(targetUserId);
-        if (targetUsername) return [roomName, targetUsername];
+        if (targetUsername) return [...names, targetUsername];
       }
-      return roomName;
+      return names.length === 1 ? names[0] : names;
     },
-    [getRoom, mDirects, mx],
+    [getRoom, mDirects, mx, localNames],
   );
 
   const [result, search, resetSearch] = useAsyncSearch(targetRooms, getTargetStr, SEARCH_OPTIONS);
@@ -388,8 +392,10 @@ export function Search({ requestClose }: SearchProps) {
                           <Box grow="Yes" alignItems="Center" gap="100">
                             <Text size="T400" truncate>
                               {queryHighlighRegex
-                                ? highlightText(queryHighlighRegex, [room.name])
+                                ? highlightText(queryHighlighRegex, [
-                                : room.name}
+                                    localNames[room.roomId] ?? room.name,
+                                  ])
+                                : (localNames[room.roomId] ?? room.name)}
                             </Text>
                             {dmUsername && (
                               <Text as="span" size="T200" priority="300" truncate>

src/app/features/settings/account/Profile.tsx

@@ -57,7 +57,7 @@ import { createUploadAtom, UploadSuccess } from '../../../state/upload';
 import { CompactUploadCardRenderer } from '../../../components/upload-card';
 import { useCapabilities } from '../../../hooks/useCapabilities';
 import { Presence, useUserPresence } from '../../../hooks/useUserPresence';
-import { noteLocalStatusWrite } from '../../../utils/ownStatusSync';
+import { DND_STATUS_SENTINEL, noteLocalStatusWrite } from '../../../utils/ownStatusSync';
 import { ProfileDecoration } from './ProfileDecoration';
 import { EmojiBoard } from '../../../components/emoji-board';
 import { useStatusPresets } from '../../../hooks/useStatusPresets';
@@ -396,7 +396,8 @@ function ProfileStatus() {
   const [presenceStatus] = useSetting(settingsAtom, 'presenceStatus');
   const [hidePresence] = useSetting(settingsAtom, 'hidePresence');
 
-  const initialStatus = presence?.status ?? localStorage.getItem(STATUS_MSG_KEY(userId)) ?? '';
+  const serverStatus = presence?.status === DND_STATUS_SENTINEL ? undefined : presence?.status;
+  const initialStatus = serverStatus ?? localStorage.getItem(STATUS_MSG_KEY(userId)) ?? '';
   const [statusMsg, setStatusMsg] = useState<string>(initialStatus);
   // True while the user has unsaved local edits — prevents a server presence
   // echo from overwriting what the user is currently typing/inserting.
@@ -442,6 +443,9 @@ function ProfileStatus() {
         pendingAppliedRef.current = null; // window elapsed — accept external changes
       }
     }
+    // [Gitea #283] "dnd" is the Do Not Disturb sentinel, not something the user
+    // typed: don't show it in the status field or keep it as their status.
+    if (remoteStatus === DND_STATUS_SENTINEL) return;
     if (remoteStatus) {
       setStatusMsg(remoteStatus);
       localStorage.setItem(STATUS_MSG_KEY(userId), remoteStatus);

src/app/hooks/usePresenceUpdater.ts

@@ -1,4 +1,5 @@
 import { useEffect, useRef } from 'react';
+import { SetPresence } from 'matrix-js-sdk';
 import { PresenceDeduper, PresenceWrite } from '../utils/presenceWrite';
 import { useMatrixClient } from './useMatrixClient';
 import { getLastLocalStatusWrite, pickHeartbeatStatus } from '../utils/ownStatusSync';
@@ -90,11 +91,21 @@ export function usePresenceUpdater() {
       return status;
     };
 
+    // [Gitea #282] A one-off PUT /presence doesn't stick: the SDK long-polls
+    // /sync with set_presence=online by default and Synapse treats every sync
+    // as "online", so Invisible / Idle / DND flipped back within seconds. Tell
+    // the sync loop which presence to report too (as Element does).
+    const syncPresence = (presence: SetPresence) => {
+      mx.setSyncPresence(presence).catch(() => undefined);
+    };
+
     const setOnline = async () => {
+      syncPresence(SetPresence.Online);
       const status = await resolveStatus();
       return send({ presence: 'online', ...(status ? { status_msg: status } : {}) }, 'online');
     };
     const setUnavailable = async (statusMsg?: string) => {
+      syncPresence(SetPresence.Unavailable);
       const status = await resolveStatus();
       return send(
         {
@@ -104,7 +115,10 @@ export function usePresenceUpdater() {
         'unavailable',
       );
     };
-    const setOffline = () => send({ presence: 'offline', status_msg: '' }, 'offline');
+    const setOffline = () => {
+      syncPresence(SetPresence.Offline);
+      return send({ presence: 'offline', status_msg: '' }, 'offline');
+    };
 
     // Manual presence overrides — no activity tracking needed.
     if (hidePresence || presenceStatus === 'invisible') {
@@ -167,13 +181,17 @@ export function usePresenceUpdater() {
       // it isn't usable here. fetch(..., { keepalive: true }) lets the request outlive the
       // page and is the correct mechanism for an authed endpoint. (keepalive bodies are
       // capped at 64KB, which this tiny payload is well under.)
+      // [Gitea #339] Synapse treats a missing status_msg as "clear it", so a bare
+      // { presence: 'offline' } wiped the user's custom status for everyone whenever
+      // any tab closed or reloaded. Send the current status along with it.
+      const status = readStatus();
       fetch(`${baseUrl}/_matrix/client/v3/presence/${encodeURIComponent(userId)}/status`, {
         method: 'PUT',
         headers: {
           Authorization: `Bearer ${token}`,
           'Content-Type': 'application/json',
         },
-        body: JSON.stringify({ presence: 'offline' }),
+        body: JSON.stringify({ presence: 'offline', ...(status ? { status_msg: status } : {}) }),
         keepalive: true,
       }).catch((err) => warnPresenceFailure('offline (pagehide)', err));
     };

src/app/hooks/useRoomMeta.ts

@@ -102,6 +102,22 @@ export const useLocalRoomName = (room: Room): string => {
   return localNames[room.roomId] ?? name;
 };
 
+/**
+ * [Gitea #336] The whole "Rename for me" map, for lists that show many rooms
+ * (quick switcher, forward/share pickers) so they use the name the user sees in
+ * the sidebar, not the server name.
+ */
+export const useLocalRoomNames = (): Readonly<Record<string, string>> => {
+  const mx = useMatrixClient();
+  return roomNamesStore.useValue(mx);
+};
+
+/** Non-hook read for notification paths (toast / OS notification titles). */
+export const getLocalRoomName = (
+  mx: ReturnType<typeof useMatrixClient>,
+  roomId: string,
+): string | undefined => roomNamesStore.getLatest(mx)[roomId];
+
 export const useHasLocalRoomName = (roomId: string): boolean => {
   const mx = useMatrixClient();
   const localNames = roomNamesStore.useValue(mx);

src/app/hooks/useVoiceChannelFull.ts

@@ -5,6 +5,7 @@ import { StateEvent } from '../../types/matrix/room';
 import { VoiceLimitContent } from '../features/common-settings/general/RoomVoiceLimit';
 import { useCallMembers, useCallSession } from './useCall';
 import { useMatrixClient } from './useMatrixClient';
+import { voiceChannelOccupancy } from '../utils/voiceChannelFull';
 
 export type VoiceChannelFull = {
   channelFull: boolean;
@@ -26,9 +27,11 @@ export const useVoiceChannelFull = (room: Room): VoiceChannelFull => {
 
   return useMemo(() => {
     const maxUsers = limitEvent?.getContent<VoiceLimitContent>().max_users ?? 0;
-    // A user already counted in the session is rejoining and should not be blocked.
+    // Distinct people, not per-device memberships (Gitea #342).
-    const alreadyMember = callMembers.some((m) => m.sender === mx.getSafeUserId());
+    return voiceChannelOccupancy(
-    const channelFull = maxUsers > 0 && !alreadyMember && callMembers.length >= maxUsers;
+      callMembers.map((m) => m.sender),
-    return { channelFull, current: callMembers.length, max: maxUsers };
+      mx.getSafeUserId(),
+      maxUsers,
+    );
   }, [limitEvent, callMembers, mx]);
 };

src/app/pages/client/ClientNonUIFeatures.tsx

@@ -14,6 +14,7 @@ import {
   ThreadEvent,
 } from 'matrix-js-sdk';
 import { useNotificationsQuiet } from '../../hooks/useNotificationsQuiet';
+import { getLocalRoomName } from '../../hooks/useRoomMeta';
 import { roomToUnreadAtom } from '../../state/room/roomToUnread';
 import NotificationSound from '../../../../public/sound/notification.ogg';
 import InviteSound from '../../../../public/sound/invite.ogg';
@@ -639,7 +640,8 @@ function MessageNotifications() {
         const avatarMxc =
           room.getAvatarFallbackMember()?.getMxcAvatarUrl() ?? room.getMxcAvatarUrl();
         notify({
-          roomName: room.name ?? 'Unknown',
+          // [Gitea #336] the user's own "Rename for me" name when they set one
+          roomName: getLocalRoomName(mx, room.roomId) ?? room.name ?? 'Unknown',
           roomAvatar: avatarMxc
             ? (mxcUrlToHttp(mx, avatarMxc, useAuthentication, 96, 96, 'crop') ?? undefined)
             : undefined,
@@ -783,15 +785,20 @@ function ReminderMonitor() {
   const { reminders, removeReminder } = useReminders();
   const setToast = useSetAtom(toastQueueAtom);
   const mDirects = useAtomValue(mDirectAtom);
+  const [showNotifications] = useSetting(settingsAtom, 'showNotifications');
+  const quietActive = useNotificationsQuiet();
   const firedRef = useRef<Set<string>>(new Set());
   const removingRef = useRef<Set<string>>(new Set());
-  // Read the latest reminders / DM map via refs so the poll interval below is
+  // Read the latest reminders / DM map / notification prefs via refs so the poll
-  // created once — not torn down and restarted (which resets its 30s countdown
+  // interval below is created once — not torn down and restarted (which resets
-  // and can indefinitely defer a near-due reminder) on every reminder sync (N115).
+  // its 30s countdown and can indefinitely defer a near-due reminder) on every
+  // reminder sync (N115).
   const remindersRef = useRef(reminders);
   remindersRef.current = reminders;
   const mDirectsRef = useRef(mDirects);
   mDirectsRef.current = mDirects;
+  const osNotifyRef = useRef(false);
+  osNotifyRef.current = showNotifications && !quietActive;
 
   useEffect(() => {
     const check = () => {
@@ -803,7 +810,7 @@ function ReminderMonitor() {
         if (!firedRef.current.has(key)) {
           firedRef.current.add(key);
           const room = mx.getRoom(r.roomId);
-          const roomName = room?.name ?? 'Unknown Room';
+          const roomName = getLocalRoomName(mx, r.roomId) ?? room?.name ?? 'Unknown Room';
           // Reminders for E2EE rooms carry no text (account data is server-
           // readable), so resolve the body from the local timeline at fire time.
           const localBody = room?.findEventById(r.eventId)?.getContent()?.body;
@@ -815,6 +822,23 @@ function ReminderMonitor() {
           const hashPath = mDirectsRef.current.has(r.roomId)
             ? getDirectRoomPath(r.roomId, r.eventId)
             : getHomeRoomPath(r.roomId, r.eventId);
+          // [Gitea #338] A reminder is only done once the user has SEEN it: the
+          // toast stays until clicked or dismissed (it used to vanish after 4 s
+          // and the reminder was deleted at once, so one due while the user was
+          // away was lost). The removal is persisted on that click/dismiss; an
+          // unseen reminder comes back on the next start.
+          const done = () => {
+            if (removingRef.current.has(key)) return;
+            removingRef.current.add(key);
+            removeReminder(r.eventId, r.timestamp).catch(() => {
+              removingRef.current.delete(key);
+            });
+          };
+          const open = () => {
+            done();
+            // window.location.hash setter auto-prepends '#' (as the toast does)
+            window.location.hash = hashPath;
+          };
           setToast({
             id: `reminder-${key}`,
             displayName: 'Reminder',
@@ -822,16 +846,30 @@ function ReminderMonitor() {
             roomName,
             roomId: r.roomId,
             hashPath,
+            sticky: true,
+            onClick: open,
+            onDismiss: done,
           });
-        }
+          // Away from the window: also raise an OS notification (the reminder is
-        // Persist the removal, retrying on a later tick if it fails — without
+          // an explicit request, but quiet hours / notifications-off win). Never
-        // re-showing the toast (N114). The server echo drops it from
+          // put decrypted E2EE text in it (N106).
-        // `reminders` once the write lands.
+          if (osNotifyRef.current && notificationPermission('granted') && !document.hasFocus()) {
-        if (!removingRef.current.has(key)) {
+            const encrypted = !!room?.hasEncryptionStateEvent();
-          removingRef.current.add(key);
+            showOsNotification(
-          removeReminder(r.eventId, r.timestamp).catch(() => {
+              'Reminder',
-            removingRef.current.delete(key);
+              {
-          });
+                icon: LogoSVG,
+                badge: LogoSVG,
+                body: encrypted ? `A message in ${roomName}` : body,
+                tag: `reminder-${key}`,
+                data: { path: hashPath, roomId: r.roomId },
+              },
+              () => {
+                window.focus();
+                open();
+              },
+            ).catch(() => undefined);
+          }
         }
       });
     };

src/app/pages/client/share/Share.tsx

@@ -38,6 +38,7 @@ import {
 import { BlockType } from '../../../components/editor';
 import { bytesToSize } from '../../../utils/common';
 import { getHomePath } from '../../pathUtils';
+import { useLocalRoomNames } from '../../../hooks/useRoomMeta';
 
 type Shared = { payload: SharePayload; files: File[] };
 
@@ -47,6 +48,7 @@ type Shared = { payload: SharePayload; files: File[] };
  * as the draft) — the user still presses Send.
  */
 export function Share() {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
   const navigate = useNavigate();
   const { navigateRoom } = useRoomNavigate();
@@ -69,8 +71,12 @@ export function Share() {
       .filter((r) => r.getMyMembership() === 'join' && !r.isSpaceRoom())
       .sort((a, b) => (b.getLastActiveTimestamp() ?? 0) - (a.getLastActiveTimestamp() ?? 0));
     const q = query.trim().toLowerCase();
-    return q ? all.filter((r) => r.name.toLowerCase().includes(q)) : all;
+    return q
-  }, [mx, query]);
+      ? all.filter((r) =>
+          [r.name, localNames[r.roomId]].some((nm) => nm?.toLowerCase().includes(q)),
+        )
+      : all;
+  }, [mx, query, localNames]);
 
   // Written straight into the room's draft atoms so its composer shows the
   // upload board + text as soon as it mounts.
@@ -210,6 +216,7 @@ function ShareRoomRow({
   disabled: boolean;
   onPick: (room: Room) => void;
 }) {
+  const localNames = useLocalRoomNames();
   const mx = useMatrixClient();
   const avatarMxc = room.getMxcAvatarUrl();
   const avatarUrl = avatarMxc
@@ -237,7 +244,7 @@ function ShareRoomRow({
     >
       <Box direction="Column">
         <Text size="T300" truncate>
-          {room.name}
+          {localNames[room.roomId] ?? room.name}
         </Text>
         {dm && (
           <Text size="T200" priority="300" truncate>

src/app/utils/ownStatusSync.test.ts

@@ -48,3 +48,34 @@ test("a fresh local save wins over a server read that hasn't caught up", () => {
     'previous',
   );
 });
+
+test('pickHeartbeatStatus: the "dnd" sentinel is never adopted as the user status (#283)', () => {
+  const base = { lastLocalWriteAt: 0, now: 100_000 };
+  // leaving DND: the server still says "dnd" → restore the real local status
+  assert.equal(
+    pickHeartbeatStatus({
+      ...base,
+      local: '🎮 Gaming',
+      server: { presence: 'unavailable', status_msg: 'dnd' },
+    }),
+    '🎮 Gaming',
+  );
+  // a local copy that had absorbed the sentinel becomes empty, not "dnd"
+  assert.equal(
+    pickHeartbeatStatus({
+      ...base,
+      local: 'dnd',
+      server: { presence: 'online', status_msg: 'dnd' },
+    }),
+    '',
+  );
+  // ordinary statuses are unaffected
+  assert.equal(
+    pickHeartbeatStatus({
+      ...base,
+      local: 'old',
+      server: { presence: 'online', status_msg: 'new' },
+    }),
+    'new',
+  );
+});

src/app/utils/ownStatusSync.ts

@@ -9,6 +9,9 @@
  * overridden by a server read that hasn't caught up yet.
  */
 
+/** The status_msg Lotus sends for Do Not Disturb (see usePresenceUpdater). */
+export const DND_STATUS_SENTINEL = 'dnd';
+
 /** Trust this device's own copy for this long after it saved or cleared it. */
 export const LOCAL_WRITE_GRACE_MS = 15_000;
 
@@ -37,7 +40,12 @@ export const pickHeartbeatStatus = ({
   lastLocalWriteAt: number;
   now: number;
 }): string => {
-  if (!server || server.presence === 'offline') return local;
+  // [Gitea #283] Lotus encodes Do Not Disturb as status_msg "dnd", so a device
-  if (now - writtenAt < LOCAL_WRITE_GRACE_MS) return local;
+  // leaving DND must not adopt that sentinel as the user's status — keep (and
+  // so restore) the real one it holds locally.
+  const mine = local === DND_STATUS_SENTINEL ? '' : local;
+  if (!server || server.presence === 'offline') return mine;
+  if (now - writtenAt < LOCAL_WRITE_GRACE_MS) return mine;
+  if (server.status_msg === DND_STATUS_SENTINEL) return mine;
   return server.status_msg ?? '';
 };

src/app/utils/voiceChannelFull.test.ts

@@ -0,0 +1,28 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { voiceChannelOccupancy } from './voiceChannelFull';
+
+test('voiceChannelOccupancy: one user on two devices fills one slot, not two', () => {
+  assert.deepEqual(voiceChannelOccupancy(['@a:x', '@a:x'], '@b:x', 2), {
+    channelFull: false,
+    current: 1,
+    max: 2,
+  });
+});
+
+test('voiceChannelOccupancy: full when distinct users reach the limit', () => {
+  assert.deepEqual(voiceChannelOccupancy(['@a:x', '@c:x', '@a:x'], '@b:x', 2), {
+    channelFull: true,
+    current: 2,
+    max: 2,
+  });
+});
+
+test('voiceChannelOccupancy: someone already in the call can always join another device', () => {
+  assert.equal(voiceChannelOccupancy(['@a:x', '@b:x'], '@b:x', 2).channelFull, false);
+});
+
+test('voiceChannelOccupancy: no limit (0) is never full; unknown senders are ignored', () => {
+  assert.equal(voiceChannelOccupancy(['@a:x', '@c:x'], '@b:x', 0).channelFull, false);
+  assert.equal(voiceChannelOccupancy([undefined, '@a:x'], '@b:x', 2).current, 1);
+});

src/app/utils/voiceChannelFull.ts

@@ -0,0 +1,25 @@
+/**
+ * [Gitea #342] Whether a voice channel with an `io.lotus.voice_limit` is full.
+ * Counts distinct PEOPLE, not call memberships: a MatrixRTC membership is per
+ * device, so one user on desktop + phone (or with a crashed tab's membership
+ * not yet expired) used to fill two slots. This matches the server-side guard
+ * (matrix `voice-limit-guard.py`, which reduces LiveKit identities to users).
+ */
+export type VoiceChannelOccupancy = {
+  channelFull: boolean;
+  /** Distinct users in the call. */
+  current: number;
+  max: number;
+};
+
+export const voiceChannelOccupancy = (
+  memberSenders: Array<string | undefined>,
+  myUserId: string,
+  maxUsers: number,
+): VoiceChannelOccupancy => {
+  const users = new Set(memberSenders.filter((s): s is string => !!s));
+  // A user already in the call (another device, or rejoining) is never blocked.
+  const alreadyMember = users.has(myUserId);
+  const channelFull = maxUsers > 0 && !alreadyMember && users.size >= maxUsers;
+  return { channelFull, current: users.size, max: maxUsers };
+};