fix typing indicator on wrong server

src/app/core/services/webrtc.service.ts

@@ -71,6 +71,7 @@ type IncomingSignalingMessage = Omit<Partial<SignalingMessage>, 'type' | 'payloa
   oderId?: string;
   serverTime?: number;
   serverId?: string;
+  serverIds?: string[];
   users?: SignalingUserSummary[];
   displayName?: string;
   fromUserId?: string;
@@ -92,8 +93,8 @@ export class WebRTCService implements OnDestroy {
   private activeServerId: string | null = null;
   /** The server ID where voice is currently active, or `null` when not in voice. */
   private voiceServerId: string | null = null;
-  /** Maps each remote peer ID to the server they were discovered from. */
-  private readonly peerServerMap = new Map<string, string>();
+  /** Maps each remote peer ID to the shared servers they currently belong to. */
+  private readonly peerServerMap = new Map<string, Set<string>>();
   private readonly serviceDestroyed$ = new Subject<void>();
   private remoteScreenShareRequestsEnabled = false;
   private readonly desiredRemoteScreenSharePeers = new Set<string>();
@@ -275,6 +276,7 @@ export class WebRTCService implements OnDestroy {
 
     this.peerManager.peerDisconnected$.subscribe((peerId) => {
       this.activeRemoteScreenSharePeers.delete(peerId);
+      this.peerServerMap.delete(peerId);
       this.screenShareManager.clearScreenShareRequest(peerId);
     });
 
@@ -349,6 +351,10 @@ export class WebRTCService implements OnDestroy {
       if (!user.oderId)
         continue;
 
+      if (message.serverId) {
+        this.trackPeerInServer(user.oderId, message.serverId);
+      }
+
       const existing = this.peerManager.activePeerConnections.get(user.oderId);
       const healthy = this.isPeerHealthy(existing);
 
@@ -367,10 +373,6 @@ export class WebRTCService implements OnDestroy {
 
       this.peerManager.createPeerConnection(user.oderId, true);
       this.peerManager.createAndSendOffer(user.oderId);
-
-      if (message.serverId) {
-        this.peerServerMap.set(user.oderId, message.serverId);
-      }
     }
   }
 
@@ -379,6 +381,10 @@ export class WebRTCService implements OnDestroy {
       displayName: message.displayName,
       oderId: message.oderId
     });
+
+    if (message.oderId && message.serverId) {
+      this.trackPeerInServer(message.oderId, message.serverId);
+    }
   }
 
   private handleUserLeftSignalingMessage(message: IncomingSignalingMessage): void {
@@ -389,8 +395,16 @@ export class WebRTCService implements OnDestroy {
     });
 
     if (message.oderId) {
-      this.peerManager.removePeer(message.oderId);
-      this.peerServerMap.delete(message.oderId);
+      const hasRemainingSharedServers = Array.isArray(message.serverIds)
+        ? this.replacePeerSharedServers(message.oderId, message.serverIds)
+        : (message.serverId
+          ? this.untrackPeerFromServer(message.oderId, message.serverId)
+          : false);
+
+      if (!hasRemainingSharedServers) {
+        this.peerManager.removePeer(message.oderId);
+        this.peerServerMap.delete(message.oderId);
+      }
     }
   }
 
@@ -404,7 +418,7 @@ export class WebRTCService implements OnDestroy {
     const offerEffectiveServer = this.voiceServerId || this.activeServerId;
 
     if (offerEffectiveServer && !this.peerServerMap.has(fromUserId)) {
-      this.peerServerMap.set(fromUserId, offerEffectiveServer);
+      this.trackPeerInServer(fromUserId, offerEffectiveServer);
     }
 
     this.peerManager.handleOffer(fromUserId, sdp);
@@ -441,8 +455,8 @@ export class WebRTCService implements OnDestroy {
   private closePeersNotInServer(serverId: string): void {
     const peersToClose: string[] = [];
 
-    this.peerServerMap.forEach((peerServerId, peerId) => {
-      if (peerServerId !== serverId) {
+    this.peerServerMap.forEach((peerServerIds, peerId) => {
+      if (!peerServerIds.has(serverId)) {
         peersToClose.push(peerId);
       }
     });
@@ -479,6 +493,45 @@ export class WebRTCService implements OnDestroy {
     return this.signalingManager.connect(serverUrl);
   }
 
+  private trackPeerInServer(peerId: string, serverId: string): void {
+    if (!peerId || !serverId)
+      return;
+
+    const trackedServers = this.peerServerMap.get(peerId) ?? new Set<string>();
+
+    trackedServers.add(serverId);
+    this.peerServerMap.set(peerId, trackedServers);
+  }
+
+  private replacePeerSharedServers(peerId: string, serverIds: string[]): boolean {
+    const sharedServerIds = serverIds.filter((serverId) => this.memberServerIds.has(serverId));
+
+    if (sharedServerIds.length === 0) {
+      this.peerServerMap.delete(peerId);
+      return false;
+    }
+
+    this.peerServerMap.set(peerId, new Set(sharedServerIds));
+    return true;
+  }
+
+  private untrackPeerFromServer(peerId: string, serverId: string): boolean {
+    const trackedServers = this.peerServerMap.get(peerId);
+
+    if (!trackedServers)
+      return false;
+
+    trackedServers.delete(serverId);
+
+    if (trackedServers.size === 0) {
+      this.peerServerMap.delete(peerId);
+      return false;
+    }
+
+    this.peerServerMap.set(peerId, trackedServers);
+    return true;
+  }
+
   /**
    * Ensure the signaling WebSocket is connected, reconnecting if needed.
    *