feat(JitsiParticipant): Add participant-level mute state change events

   Adds TRACK_AUDIO_MUTED_CHANGED and TRACK_VIDEO_MUTED_CHANGED events that emit when a participant's aggregate mute state changes. A participant is considered unmuted
    if ANY source for that media type is unmuted.

   Also fixes bug where sources weren't added when media type map didn't exist.

Author: mihhu

JitsiConferenceEvents.ts

@@ -412,6 +412,13 @@ export enum JitsiConferenceEvents {
      */
     TRACK_AUDIO_LEVEL_CHANGED = 'conference.audioLevelsChanged',
 
+    /**
+     * A remote participant's audio mute status changed based on signaling.
+     * @param {JitsiParticipant} participant - The participant whose audio mute status changed
+     * @param {boolean} muted - true if muted, false if unmuted
+     */
+    TRACK_AUDIO_MUTED_CHANGED = 'conference.trackAudioMutedChanged',
+
     /**
      * A media track ( attached to the conference) mute status was changed.
      * @param {JitsiParticipant|null} the participant that initiated the mute
@@ -433,6 +440,13 @@ export enum JitsiConferenceEvents {
      */
     TRACK_UNMUTE_REJECTED = 'conference.trackUnmuteRejected',
 
+    /**
+     * A remote participant's video mute status changed based on signaling.
+     * @param {JitsiParticipant} participant - The participant whose video mute status changed
+     * @param {boolean} muted - true if muted, false if unmuted
+     */
+    TRACK_VIDEO_MUTED_CHANGED = 'conference.trackVideoMutedChanged',
+
     /**
      * Notifies for transcription status changes. The event provides the
      * following parameters to its listeners:

JitsiParticipant.ts

@@ -30,6 +30,8 @@ export default class JitsiParticipant {
     private _isSilent?: boolean;
     private _features: Set<string>;
     private _sources: Map<MediaType, Map<string, ISourceInfo>>;
+    private _previousAudioMuted?: boolean;
+    private _previousVideoMuted?: boolean;
     private _botType?: string;
     private _connectionJid?: string;
     /**
@@ -142,13 +144,41 @@ export default class JitsiParticipant {
 
         if (sourceByMediaType?.size) {
             sourceByMediaType.set(sourceName, sourceInfo);
+        } else {
+            sourceByMediaType = new Map();
+            sourceByMediaType.set(sourceName, sourceInfo);
+            this._sources.set(mediaType, sourceByMediaType);
+        }
 
-            return;
+        // Calculate aggregate mute state for the media type
+        // If ANY source is unmuted, consider the media type unmuted
+        let isMediaTypeMuted = true;
+
+        for (const source of sourceByMediaType.values()) {
+            if (!source.muted) {
+                isMediaTypeMuted = false;
+                break;
+            }
         }
 
-        sourceByMediaType = new Map();
-        sourceByMediaType.set(sourceName, sourceInfo);
-        this._sources.set(mediaType, sourceByMediaType);
+        // Detect mute state changes and emit events
+        if (mediaType === MediaType.AUDIO) {
+            if (this._previousAudioMuted !== undefined && this._previousAudioMuted !== isMediaTypeMuted) {
+                this._conference.eventEmitter.emit(
+                    JitsiConferenceEvents.TRACK_AUDIO_MUTED_CHANGED,
+                    this,
+                    isMediaTypeMuted);
+            }
+            this._previousAudioMuted = isMediaTypeMuted;
+        } else if (mediaType === MediaType.VIDEO) {
+            if (this._previousVideoMuted !== undefined && this._previousVideoMuted !== isMediaTypeMuted) {
+                this._conference.eventEmitter.emit(
+                    JitsiConferenceEvents.TRACK_VIDEO_MUTED_CHANGED,
+                    this,
+                    isMediaTypeMuted);
+            }
+            this._previousVideoMuted = isMediaTypeMuted;
+        }
     }
 
     /**