@ermis-network/ermis-chat-sdk 1.0.8 → 2.0.0

package/src/ermis_call_node.ts

@@ -1,5 +1,5 @@
 import { ErmisChat } from './client';
-import init, { ErmisCall } from './wasm/ermis_call_node_wasm';
+import { WasmWorkerProxy } from './wasm_worker_proxy';
 import {
   CallAction,
   CallEventData,
@@ -16,6 +16,7 @@ import { MediaStreamReceiver } from './media_stream_receiver';
 
 export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = DefaultGenerics> {
   wasmPath: string;
+  workerPath: string;
 
   relayUrl = 'https://test-iroh.ermis.network.:8443';
 
@@ -31,15 +32,17 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
   /** Type of call: 'audio' or 'video' */
   callType?: string;
 
-  /** ID of the current user */
-  userID?: string | undefined;
+  /** ID of the current user — always reads live value from client */
+  get userID(): string | undefined {
+    return this._client?.userID;
+  }
 
   /** Current status of the call */
   callStatus? = '';
 
   metadata?: Metadata;
 
-  callNode: ErmisCall | null = null;
+  callNode: WasmWorkerProxy | null = null;
 
   /** Local media stream from user's camera/microphone */
   localStream?: MediaStream | null = null;
@@ -131,15 +134,22 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
   public mediaSender: MediaStreamSender | null = null;
   public mediaReceiver: MediaStreamReceiver | null = null;
 
-  constructor(client: ErmisChat<ErmisChatGenerics>, sessionID: string, wasmPath: string, relayUrl: string) {
+  constructor(
+    client: ErmisChat<ErmisChatGenerics>,
+    sessionID: string,
+    wasmPath: string,
+    relayUrl: string,
+    workerPath?: string,
+  ) {
     this._client = client;
     this.cid = '';
     this.callType = '';
     this.sessionID = sessionID;
-    this.userID = client.userID;
+    // userID is now a getter — reads from this._client.userID directly
     this.metadata = {};
     this.wasmPath = wasmPath;
     this.relayUrl = relayUrl;
+    this.workerPath = workerPath || '/wasm_worker.worker.mjs';
 
     this.listenSocketEvents();
     this.setupDeviceChangeListener();
@@ -148,24 +158,32 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
 
   private async loadWasm(): Promise<void> {
     try {
-      await init(this.wasmPath);
+      // Tạo Worker proxy — WASM chạy hoàn toàn trên Worker thread
+      this.callNode = new WasmWorkerProxy(new URL(this.workerPath, window.location.origin));
+      await this.callNode.init(this.wasmPath);
     } catch (error) {
-      console.error('Failed to load ErmisCall WASM module:', error);
+      console.error('Failed to load ErmisCall WASM Worker:', error);
       throw error;
     }
   }
 
-  private async initialize(): Promise<ErmisCall> {
+  private async initialize(): Promise<WasmWorkerProxy> {
     try {
-      const node = new ErmisCall();
-      await node.spawn([this.relayUrl]);
-      this.callNode = node;
+      // Re-create Worker nếu đã bị terminate bởi call trước
+      // (Worker mới nhưng dùng cached Blob URL + compiled WASM Module → rất nhanh)
+      if (!this.callNode) {
+        await this.loadWasm();
+      }
+
+      const proxy = this.callNode!;
+
+      await proxy.spawn([this.relayUrl]);
 
-      // 1. Init Sender
-      this.mediaSender = new MediaStreamSender(node as any);
+      // 1. Init Sender — proxy implements INodeCall
+      this.mediaSender = new MediaStreamSender(proxy as any);
 
-      // 2. Init Receiver
-      this.mediaReceiver = new MediaStreamReceiver(node as any, {
+      // 2. Init Receiver — proxy implements INodeCall
+      this.mediaReceiver = new MediaStreamReceiver(proxy as any, {
         onConnected: () => {
           this.setCallStatus(CallStatus.CONNECTED);
           this.connectCall();
@@ -207,7 +225,10 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
         },
       });
 
-      return node;
+      // Bắt đầu recv loop trong Worker
+      await proxy.startRecvLoop();
+
+      return proxy;
     } catch (error) {
       console.error('Failed to initialize Ermis SDK:', error);
       throw error;
@@ -258,13 +279,13 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
       if (typeof this.onError === 'function') {
         if (error.code === 'ERR_NETWORK') {
           if (action === CallAction.CREATE_CALL) {
-            this.onError('Unable to make the call. Please check your network connection');
+            this.onError('call_network_error');
           }
         } else {
           if (error.response.data.ermis_code === 20) {
-            this.onError('Recipient was busy');
+            this.onError('call_recipient_busy');
           } else {
-            const errMsg = error.response.data?.message ? error.response.data?.message : 'Call failed';
+            const errMsg = error.response.data?.message ? error.response.data?.message : 'call_failed';
             this.onError(errMsg);
           }
         }
@@ -356,7 +377,7 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
 
       // No device found at all — report error
       if (typeof this.onError === 'function') {
-        this.onError('No microphone or camera found. Please check your device.');
+        this.onError('call_no_devices');
       }
       return null;
     }
@@ -391,27 +412,41 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
   private setUserInfo(cid: string | undefined, eventUserId: string | undefined) {
     if (!cid || !eventUserId) return;
 
-    // Get caller and receiver userId from activeChannels
     const channel = cid ? this.getClient().activeChannels[cid] : undefined;
-    const members = channel?.state?.members || {};
-    const memberIds = Object.keys(members);
+    const stateMembers = channel?.state?.members || {};
+    const memberIds = Object.keys(stateMembers);
 
-    // callerId is eventUserId, receiverId is the other user in the channel
     const callerId = eventUserId || '';
     const receiverId = memberIds.find((id) => id !== callerId) || '';
 
-    // Get user info from client.state.users
-    const callerUser = this.getClient().state.users[callerId];
-    const receiverUser = this.getClient().state.users[receiverId];
+    // Try multiple sources for user info (in order of reliability):
+    // 1. channel.data.members (enriched array from watch/query — most reliable)
+    // 2. channel.state.members[id].user (may be overwritten by async event handlers)
+    // 3. client.state.users (may not be populated due to disabled updateUser in updateUserReference)
+    const dataMembers: any[] = (channel?.data as any)?.members || [];
+
+    const findUserFromDataMembers = (userId: string) => {
+      const member = dataMembers.find((m: any) => m.user_id === userId || m.user?.id === userId);
+      return member?.user;
+    };
+
+    const callerUser =
+      findUserFromDataMembers(callerId) ||
+      (stateMembers[callerId] as any)?.user ||
+      this.getClient().state.users[callerId];
+    const receiverUser =
+      findUserFromDataMembers(receiverId) ||
+      (stateMembers[receiverId] as any)?.user ||
+      this.getClient().state.users[receiverId];
 
     this.callerInfo = {
       id: callerId,
-      name: callerUser?.name,
+      name: callerUser?.name || callerId,
       avatar: callerUser?.avatar || '',
     };
     this.receiverInfo = {
       id: receiverId,
-      name: receiverUser?.name,
+      name: receiverUser?.name || receiverId,
       avatar: receiverUser?.avatar || '',
     };
   }
@@ -435,7 +470,6 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
           this.callType = is_video ? 'video' : 'audio';
 
           this.setUserInfo(cid, eventUserId);
-          this.setCallStatus(CallStatus.RINGING);
           this.cid = cid || '';
           this.metadata = metadata || {};
 
@@ -450,6 +484,8 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
             });
           }
 
+          this.setCallStatus(CallStatus.RINGING);
+
           await this.startLocalStream();
           if (this.callStatus === CallStatus.ENDED) return;
 
@@ -457,11 +493,6 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
             await this.initialize();
           }
 
-          if (this.localStream && this.mediaSender && this.mediaReceiver) {
-            this.mediaSender?.initEncoders(this.localStream);
-            this.mediaReceiver?.initDecoders(this.callType);
-          }
-
           if (eventUserId === this.userID) {
             // Set missCall timeout if no connection after 60s
             if (this.missCallTimeout) clearTimeout(this.missCallTimeout);
@@ -479,9 +510,20 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
           }
 
           if (eventUserId !== this.userID && !this.isDestroyed) {
+            // Caller side: establish peer connection FIRST
             if (this.mediaReceiver && this.mediaSender) {
               await this.mediaReceiver.acceptConnection();
               await this.mediaSender.sendConnected();
+            }
+
+            // Then init encoders/decoders (safe to sendControlFrame now)
+            if (this.localStream && this.mediaSender && this.mediaReceiver && this.callType) {
+              this.mediaSender?.initEncoders(this.localStream);
+              this.mediaReceiver?.initDecoders(this.callType);
+            }
+
+            // Re-send configs after encoders have populated them
+            if (this.mediaSender) {
               await this.mediaSender.sendConfigs();
             }
           }
@@ -491,7 +533,7 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
         case CallAction.REJECT_CALL:
         case CallAction.MISS_CALL:
           // this.setCallStatus(CallStatus.ENDED);
-          this.destroy();
+          await this.destroy();
           break;
       }
     };
@@ -548,7 +590,7 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
     this._client.on('message.updated', this.messageUpdatedHandler);
   }
 
-  private cleanupCall() {
+  private async cleanupCall() {
     if (this.mediaSender) {
       this.mediaSender?.stop();
       this.mediaSender = null;
@@ -559,12 +601,12 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
     }
 
     if (this.callNode) {
-      this.callNode?.closeEndpoint();
-
-      if (this.callStatus === CallStatus.CONNECTED) {
-        this.callNode?.closeConnection();
+      try {
+        // Timeout protection: don't let terminate() hang forever
+        await Promise.race([this.callNode.terminate(), new Promise((resolve) => setTimeout(resolve, 1000))]);
+      } catch {
+        /* ignore — Worker may already be dead */
       }
-
       this.callNode = null;
     }
 
@@ -613,11 +655,11 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
     this.setCallStatus(CallStatus.ENDED);
   }
 
-  private destroy() {
+  public async destroy() {
     // if (this.signalHandler) this._client.off('signal', this.signalHandler);
     // if (this.connectionChangedHandler) this._client.off('connection.changed', this.connectionChangedHandler);
     // if (this.messageUpdatedHandler) this._client.off('message.updated', this.messageUpdatedHandler);
-    this.cleanupCall();
+    await this.cleanupCall();
   }
 
   public async getDevices(): Promise<{ audioDevices: MediaDeviceInfo[]; videoDevices: MediaDeviceInfo[] }> {
@@ -652,9 +694,15 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
     };
   }
 
+  public prefillUserInfo(cid: string) {
+    this.setUserInfo(cid, this.userID);
+  }
+
   public async createCall(callType: string, cid: string) {
     try {
       this.cid = cid;
+      this.callType = callType;
+      this.prefillUserInfo(cid);
 
       const address = await this.getLocalEndpointAddr();
 
@@ -674,10 +722,22 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
     try {
       await this._sendSignal({ action: CallAction.ACCEPT_CALL });
 
+      // Receiver side: establish peer connection FIRST
       if (this.mediaSender) {
         const address = this.metadata?.address || '';
         await this.mediaSender.connect(address);
       }
+
+      // Then init encoders/decoders (safe to sendControlFrame now)
+      if (this.localStream && this.mediaSender && this.mediaReceiver) {
+        this.mediaSender?.initEncoders(this.localStream);
+        this.mediaReceiver?.initDecoders(this.callType || 'audio');
+      }
+
+      // Re-send configs after encoders have populated them
+      if (this.mediaSender) {
+        await this.mediaSender.sendConfigs();
+      }
     } catch (error) {
       console.error('Failed to accept call:', error);
       throw error;
@@ -816,7 +876,7 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
           track.stop();
           this.localStream?.removeTrack(track);
         });
-        
+
         // Add new camera track
         this.localStream.addTrack(cameraTrack);
       } else {
@@ -879,22 +939,22 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
 
       if (!this.localStream) return false;
 
+      // Lấy lại cấu hình chuẩn để không mất khử ồn, channelCount, v.v.
+      const mediaConstraints = await this.getMediaConstraints();
+
       // Get new audio stream with selected device
       const newStream = await navigator.mediaDevices.getUserMedia({
-        audio: { deviceId: { exact: deviceId } },
+        audio: mediaConstraints.audio,
         video: false,
       });
 
       const newAudioTrack = newStream.getAudioTracks()[0];
       const oldAudioTrack = this.localStream.getAudioTracks()[0];
 
-      // Replace audio track in peer connection
-      // if (this.peer && oldAudioTrack) {
-      //   const sender = this.peer.getSenders().find((s) => s.track === oldAudioTrack);
-      //   if (sender) {
-      //     await sender.replaceTrack(newAudioTrack);
-      //   }
-      // }
+      // Replace audio track in custom encoder pipeline
+      if (this.mediaSender && newAudioTrack) {
+        await this.mediaSender.replaceAudioTrack(newAudioTrack);
+      }
 
       // Replace audio track in local stream
       if (oldAudioTrack) {
@@ -935,15 +995,23 @@ export class ErmisCallNode<ErmisChatGenerics extends ExtendableGenerics = Defaul
 
       if (!this.localStream) return false;
 
+      // Lấy lại cấu hình chuẩn để không mất độ phân giải
+      const mediaConstraints = await this.getMediaConstraints();
+
       // Get new video stream with selected device
       const newStream = await navigator.mediaDevices.getUserMedia({
         audio: false,
-        video: { deviceId: { exact: deviceId } },
+        video: mediaConstraints.video,
       });
 
       const newVideoTrack = newStream.getVideoTracks()[0];
       const oldVideoTrack = this.localStream.getVideoTracks()[0];
 
+      // Replace video track in custom encoder pipeline
+      if (this.mediaSender && newVideoTrack) {
+        await this.mediaSender.replaceVideoTrack(newVideoTrack);
+      }
+
       // Replace video track in local stream
       if (oldVideoTrack) {
         this.localStream.removeTrack(oldVideoTrack);

package/src/index.ts

@@ -10,7 +10,8 @@ export * from './ermis_call_node';
 export * from './auth';
 export { chatCodes, logChatPromiseExecution, formatMessage, createForwardMessagePayload } from './utils';
 export { parseSystemMessage } from './system_message';
+export type { SystemMessageTranslations } from './system_message';
 export { parseSignalMessage, CallType } from './signal_message';
-export type { SignalMessageResult, CallTypeValue } from './signal_message';
+export type { SignalMessageResult, CallTypeValue, SignalMessageTranslations } from './signal_message';
 export { normalizeFileName, getAttachmentCategory, isVideoFile, isHeicFile, buildAttachmentPayload } from './attachment_utils';
 export type { VoiceRecordingMeta } from './attachment_utils';

package/src/media_stream_receiver.ts

@@ -2,9 +2,8 @@ import { replaceCodecNumber } from './utils';
 import { FRAME_TYPE, IMediaReceiverEvents, INodeCall, VideoConfig } from './types';
 import { HEVCDecoderConfigurationRecord } from './hevc_decoder_config';
 
-// Các biến cấu hình Audio Sync
-const MAX_AUDIO_LATENCY = 0.1; // 100ms
-const MIN_BUFFER_AHEAD = 0.02; // 20ms
+const MAX_AUDIO_LATENCY = 0.5; // 500ms
+const MIN_BUFFER_AHEAD = 0.05; // 50ms
 
 export class MediaStreamReceiver {
   private videoDecoder: VideoDecoder | null = null;
@@ -15,10 +14,13 @@ export class MediaStreamReceiver {
 
   private audioContext: AudioContext | null = null;
   private mediaDestination: MediaStreamAudioDestinationNode | null = null;
+  private scheduledAudioNodes: AudioBufferSourceNode[] = [];
 
   private isWaitingForKeyFrame: boolean = true;
   private nextStartTime: number = 0;
   private lastVideoConfig: VideoConfig | null = null;
+  private lastVideoConfigStr: string = '';
+  private lastAudioConfigStr: string = '';
 
   private nodeCall: INodeCall;
   private events: IMediaReceiverEvents;
@@ -137,14 +139,17 @@ export class MediaStreamReceiver {
         this.isWaitingForKeyFrame = true;
 
         if (this.videoWriter) {
-          // Chỉ hồi sinh nếu Writer vẫn còn sống
-          console.log('♻️ Attempting to respawn VideoDecoder...');
-          this.setupVideoDecoder();
-          if (this.lastVideoConfig && this.videoDecoder) {
-            try {
-              this.videoDecoder.configure(this.lastVideoConfig);
-            } catch (configErr) {}
-          }
+          // Tránh hồi sinh ngay lập tức gây vòng lặp vô hạn (Infinite Loop) nếu stream bị hỏng nặng
+          console.log('♻️ Scheduled VideoDecoder respawn in 1000ms...');
+          setTimeout(() => {
+            if (!this.videoWriter) return;
+            this.setupVideoDecoder();
+            if (this.lastVideoConfig && this.videoDecoder) {
+              try {
+                this.videoDecoder.configure(this.lastVideoConfig);
+              } catch (configErr) { }
+            }
+          }, 1000);
         }
       },
     });
@@ -165,20 +170,28 @@ export class MediaStreamReceiver {
 
       // --- XỬ LÝ LATENCY & SYNC ---
       if (this.nextStartTime < currentTime) {
-        this.nextStartTime = currentTime;
+        this.nextStartTime = currentTime + MIN_BUFFER_AHEAD;
       } else if (this.nextStartTime > currentTime + MAX_AUDIO_LATENCY) {
-        // Nếu buffer quá lớn (latency cao), reset về thời điểm hiện tại
+        // Nếu buffer quá lớn (latency cao), reset về thời điểm hiện tại cộng khoảng đệm
         this.nextStartTime = currentTime + MIN_BUFFER_AHEAD;
+
+        // Dọn dẹp các audio node cũ đang được lên lịch để tránh phát đè (overlap) gây nổ/méo tiếng
+        this.scheduledAudioNodes.forEach((node) => {
+          try {
+            node.stop();
+          } catch (e) {
+            /* ignore */
+          }
+        });
+        this.scheduledAudioNodes = [];
       }
 
       const audioBuffer = this.audioContext.createBuffer(numberOfChannels, numberOfFrames, sampleRate);
-      const size = numberOfChannels * numberOfFrames;
-      const tempBuffer = new Float32Array(size);
-
-      audioData.copyTo(tempBuffer, { planeIndex: 0, format: 'f32-planar' });
 
+      // Lấy data đúng cho từng channel đối với âm thanh stereo/đa kênh
       for (let ch = 0; ch < numberOfChannels; ch++) {
-        const channelData = tempBuffer.subarray(ch * numberOfFrames, (ch + 1) * numberOfFrames);
+        const channelData = new Float32Array(numberOfFrames);
+        audioData.copyTo(channelData, { planeIndex: ch, format: 'f32-planar' });
         audioBuffer.copyToChannel(channelData, ch);
       }
 
@@ -186,6 +199,23 @@ export class MediaStreamReceiver {
       source.buffer = audioBuffer;
       source.connect(this.mediaDestination);
 
+      this.scheduledAudioNodes.push(source);
+
+      // Quick Fix: Cap the buffer size to prevent memory/CPU accumulation on jittery networks (e.g. 3G)
+      // If we have too many scheduled nodes, it means the network is jittery or the clock is drifting.
+      // Dropping oldest nodes prevents a total UI freeze after ~1 minute of instability.
+      if (this.scheduledAudioNodes.length > 100) {
+        const oldestNode = this.scheduledAudioNodes.shift();
+        try {
+          oldestNode?.stop();
+          oldestNode?.disconnect();
+        } catch (e) { /* ignore */ }
+      }
+
+      source.onended = () => {
+        this.scheduledAudioNodes = this.scheduledAudioNodes.filter((n) => n !== source);
+      };
+
       source.start(this.nextStartTime);
       this.nextStartTime += duration;
 
@@ -211,8 +241,17 @@ export class MediaStreamReceiver {
   // Vòng lặp chính xử lý dữ liệu
   public receiveLoop = async (): Promise<void> => {
     const textDecoder = new TextDecoder();
+    let lastYieldTime = Date.now();
 
     while (true) {
+      // Force a macro-task yield every 16ms (roughly every frame) to prevent Main Thread starvation.
+      // This is crucial because if nodeCall.asyncRecv() returns data from a local buffer, 
+      // the 'await' might resolve as a micro-task, which blocks UI painting/interaction.
+      if (Date.now() - lastYieldTime > 16) {
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        lastYieldTime = Date.now();
+      }
+
       try {
         if (!this.nodeCall) break;
 
@@ -249,6 +288,7 @@ export class MediaStreamReceiver {
             FRAME_TYPE.REQUEST_CONFIG,
             FRAME_TYPE.REQUEST_KEY_FRAME,
             FRAME_TYPE.END_CALL,
+            FRAME_TYPE.HEALTH_CALL,
           ] as number[]
         ).includes(frameType)
           ? 1
@@ -261,8 +301,15 @@ export class MediaStreamReceiver {
           case FRAME_TYPE.VIDEO_CONFIG: {
             try {
               const videoConfigStr = textDecoder.decode(payload);
+
+              // Deduplicate: Don't re-configure if config hasn't changed (saves CPU on unstable networks)
+              if (this.lastVideoConfigStr === videoConfigStr && this.videoDecoder?.state === 'configured') {
+                break;
+              }
+              this.lastVideoConfigStr = videoConfigStr;
               const videoConfig = JSON.parse(videoConfigStr);
-              console.log('--videoConfig--', videoConfig);
+
+              console.log('videoConfig', videoConfig);
 
               // Setup Video Track Writer & Combine Streams
               if (!this.videoWriter) {
@@ -331,15 +378,27 @@ export class MediaStreamReceiver {
 
           // --- AUDIO CONFIG ---
           case FRAME_TYPE.AUDIO_CONFIG: {
-            const audioConfig = JSON.parse(textDecoder.decode(payload));
-            console.log('--audioConfig--', audioConfig);
-
-            if (this.audioDecoder?.state !== 'closed') {
-              this.audioDecoder?.configure({
-                codec: audioConfig.codec,
-                sampleRate: audioConfig.sampleRate,
-                numberOfChannels: audioConfig.numberOfChannels,
-              });
+            try {
+              const audioConfigStr = textDecoder.decode(payload);
+
+              // Deduplicate audio config
+              if (this.lastAudioConfigStr === audioConfigStr && this.audioDecoder?.state === 'configured') {
+                break;
+              }
+              this.lastAudioConfigStr = audioConfigStr;
+              const audioConfig = JSON.parse(audioConfigStr);
+
+              console.log('audioConfig', audioConfig);
+
+              if (this.audioDecoder?.state !== 'closed') {
+                this.audioDecoder?.configure({
+                  codec: audioConfig.codec,
+                  sampleRate: audioConfig.sampleRate,
+                  numberOfChannels: audioConfig.numberOfChannels,
+                });
+              }
+            } catch (e) {
+              console.error('❌ Error processing AUDIO_CONFIG:', e);
             }
             break;
           }
@@ -352,13 +411,12 @@ export class MediaStreamReceiver {
 
             if (this.isWaitingForKeyFrame) {
               if (!isKeyFrame) break;
-              console.log('✅ Resumed decoding at KeyFrame');
+              // console.log('✅ Resumed decoding at KeyFrame');
               this.isWaitingForKeyFrame = false;
             }
 
-            if (!isKeyFrame && this.videoDecoder.decodeQueueSize > 15) {
-              console.warn('⚠️ Queue > 15. Dropping & Waiting for KeyFrame...');
-              // Nếu drop bất kỳ frame nào, ta phải chờ Key Frame tiếp theo mới decode được
+            // Stricter Backpressure: Nếu queue > 5, drop ngay lập tức các frame không quan trọng
+            if (!isKeyFrame && this.videoDecoder.decodeQueueSize > 5) {
               this.isWaitingForKeyFrame = true;
               break;
             }
@@ -458,13 +516,16 @@ export class MediaStreamReceiver {
             }
             break;
 
+          case FRAME_TYPE.HEALTH_CALL:
+            // Keep-alive ping from peer — silently acknowledge
+            break;
+
           default:
-            console.warn('❓ Unknown frame type received:', frameType);
+            // Mute unknown frame logs to save CPU and RAM
             break;
         }
       } catch (error) {
-        console.error('Stream loop error', error);
-        // Có thể thêm delay nhỏ ở đây để tránh spam error nếu loop lỗi liên tục
+        // console.error('Stream loop error', error);
         await new Promise((r) => setTimeout(r, 200));
       }
     }
@@ -511,6 +572,13 @@ export class MediaStreamReceiver {
       this.audioContext = null;
     }
 
+    this.scheduledAudioNodes.forEach((node) => {
+      try {
+        node.stop();
+      } catch (e) {}
+    });
+    this.scheduledAudioNodes = [];
+
     // Reset các biến
     this.isWaitingForKeyFrame = true;
     this.mediaDestination = null;