yeet

modules/errors/av_errors/AVError.tsx

@@ -0,0 +1,246 @@
+// Metro module 8852 (f8853).
+import _objectWithoutProperties from "../../../_bundle/_objectWithoutProperties";
+import Logger from "../../debug/Logger";
+import Dispatcher from "../../../Dispatcher";
+let c5776_1;
+const _excluded = ["type"];
+let c5775_4 = new Logger("AVError");
+const r10 = {
+  STREAM_FAILED_TO_START: "stream-failed-to-start",
+  NO_INPUT_DEVICES: "no-input-devices",
+  NO_AUDIO_INPUT_DETECTED: "no-audio-input-detected",
+  DEBUG_LOG_UPLOAD_FAILED: "debug-log-upload-failed",
+  STREAM_VIEW_LOW_FPS: "stream-view-low-fps",
+  STREAM_VIEW_HIGH_PACKET_LOSS: "stream-view-high-packet-loss",
+  STREAM_SEND_LOW_FPS: "stream-send-low-encode-fps",
+  STREAM_SEND_HIGH_PACKET_LOSS: "stream-send-high-packet-loss",
+  STREAM_BAD_NETWORK_QUALITY: "stream-send-network-quality",
+  STREAM_SOUNDSHARE_FAILED: "stream-soundshare-failed",
+  NOISE_CANCELLER_ERROR: "noise-canceller-error",
+  SCREENSHARE_OS_NOT_SUPPORTED: "screenshare-min-os-requirement",
+  STREAM_RECONNECTING: "stream-reconnecting",
+  VIDEO_DECODE_ERROR: "video-decode-error",
+  VIDEO_ENCODE_ERROR: "video-encode-error",
+  STREAM_FULL: "stream-full",
+  AUDIO_CAPTURE_SAMPLE_RATE_MISMATCH: "audio-capture-sample-rate-mismatch",
+  VIDEO_STREAM_SENDER_READY_TIMEOUT: "video-stream-sender-ready-timeout",
+  VIDEO_STREAM_RECEIVER_READY_TIMEOUT: "video-stream-receiver-ready-timeout",
+  VIDEO_STREAM_SENDER_READY_TIMEOUT_NO_STREAM: "video-stream-sender-ready-timeout-no-stream",
+  VIDEO_STREAM_RECEIVER_READY_TIMEOUT_NO_STREAM: "video-stream-receiver-ready-timeout-no-stream",
+  CAMERA_SEND_LOW_FPS: "camera-send-low-encode-fps",
+  SCREENSHARE_OS_ERROR: "screenshare-os-error",
+  VIDEO_BACKGROUND_UNAVAILABLE: "video-background-unavailable"
+};
+const r9 = {
+  Audio: "audio",
+  Video: "video",
+  Devices: "devices",
+  Debug: "debug"
+};
+const r56 = {
+  Critical: "critical",
+  Warning: "warning",
+  Info: "info"
+};
+const r60 = {};
+r60[r10.STREAM_SOUNDSHARE_FAILED] = {
+  errorCode: 1001,
+  severity: r56.Warning,
+  category: r9.Audio,
+  isErrorOutbound: true
+};
+r60[r10.NOISE_CANCELLER_ERROR] = {
+  errorCode: 1002,
+  severity: r56.Warning,
+  category: r9.Audio,
+  isErrorOutbound: true
+};
+r60[r10.AUDIO_CAPTURE_SAMPLE_RATE_MISMATCH] = {
+  errorCode: 1003,
+  severity: r56.Warning,
+  category: r9.Audio,
+  isErrorOutbound: true
+};
+r60[r10.STREAM_FAILED_TO_START] = {
+  errorCode: 2001,
+  severity: r56.Critical,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.STREAM_VIEW_LOW_FPS] = {
+  errorCode: 2002,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: false
+};
+r60[r10.STREAM_VIEW_HIGH_PACKET_LOSS] = {
+  errorCode: 2003,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: false
+};
+r60[r10.STREAM_SEND_HIGH_PACKET_LOSS] = {
+  errorCode: 2004,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.STREAM_SEND_LOW_FPS] = {
+  errorCode: 2005,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.STREAM_BAD_NETWORK_QUALITY] = {
+  errorCode: 2006,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.STREAM_RECONNECTING] = {
+  errorCode: 2007,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: false
+};
+r60[r10.VIDEO_DECODE_ERROR] = {
+  errorCode: 2008,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: false
+};
+r60[r10.VIDEO_ENCODE_ERROR] = {
+  errorCode: 2009,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.STREAM_FULL] = {
+  errorCode: 2010,
+  severity: r56.Critical,
+  category: r9.Video,
+  isErrorOutbound: false
+};
+r60[r10.VIDEO_STREAM_SENDER_READY_TIMEOUT] = {
+  errorCode: 2011,
+  severity: r56.Critical,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.VIDEO_STREAM_RECEIVER_READY_TIMEOUT] = {
+  errorCode: 2012,
+  severity: r56.Critical,
+  category: r9.Video,
+  isErrorOutbound: false
+};
+r60[r10.CAMERA_SEND_LOW_FPS] = {
+  errorCode: 2013,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.VIDEO_STREAM_SENDER_READY_TIMEOUT_NO_STREAM] = {
+  errorCode: 2014,
+  severity: r56.Critical,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.VIDEO_STREAM_RECEIVER_READY_TIMEOUT_NO_STREAM] = {
+  errorCode: 2015,
+  severity: r56.Critical,
+  category: r9.Video,
+  isErrorOutbound: false
+};
+r60[r10.VIDEO_BACKGROUND_UNAVAILABLE] = {
+  errorCode: 2016,
+  severity: r56.Warning,
+  category: r9.Video,
+  isErrorOutbound: true
+};
+r60[r10.NO_INPUT_DEVICES] = {
+  errorCode: 3001,
+  severity: r56.Critical,
+  category: r9.Devices,
+  isErrorOutbound: true
+};
+r60[r10.NO_AUDIO_INPUT_DETECTED] = {
+  errorCode: 3002,
+  severity: r56.Critical,
+  category: r9.Devices,
+  isErrorOutbound: true
+};
+r60[r10.SCREENSHARE_OS_NOT_SUPPORTED] = {
+  errorCode: 3003,
+  severity: r56.Critical,
+  category: r9.Devices,
+  isErrorOutbound: true
+};
+r60[r10.SCREENSHARE_OS_ERROR] = {
+  errorCode: 3004,
+  severity: r56.Critical,
+  category: r9.Devices,
+  isErrorOutbound: true
+};
+r60[r10.DEBUG_LOG_UPLOAD_FAILED] = {
+  errorCode: 4001,
+  severity: r56.Info,
+  category: r9.Debug,
+  isErrorOutbound: true
+};
+let c5775_5 = r60;
+const r157 = {
+  Unknown: "Unknown",
+  UploadErrorGeneral: "UploadErrorCodes.GENERAL",
+  UploadErrorNoFile: "UploadErrorCodes.NO_FILE",
+  UploadErrorProgress: "UploadErrorCodes.PROGRESS",
+  UploadErrorUpload: "UploadErrorCodes.UPLOAD",
+  UploadErrorRead: "UploadErrorCodes.READ",
+  KrispCpuOveruse: "NoiseCancellerError.CPU_OVERUSE",
+  KrispFailed: "NoiseCancellerError.FAILED",
+  KrispVadCpuOveruse: "NoiseCancellerError.VAD_CPU_OVERUSE",
+  KrispInitError: "NoiseCancellerError.INIT_ERROR",
+  KrispInitErrorNative: "NoiseCancellerError.INIT_ERROR_NATIVE",
+  KrispInitErrorSse4NotSupported: "NoiseCancellerError.KRISP_INIT_ERROR_SSE4_NOT_SUPPORTED",
+  KrispInitErrorAvx2NotSupported: "NoiseCancellerError.KRISP_INIT_ERROR_AVX2_NOT_SUPPORTED",
+  KrispInitErrorUnsigned: "NoiseCancellerError.KRISP_INIT_ERROR_UNSIGNED",
+  KrispInitErrorGlobalInit: "NoiseCancellerError.KRISP_INIT_ERROR_GLOBAL_INIT",
+  KrispInitErrorWeight8k: "NoiseCancellerError.KRISP_INIT_ERROR_WEIGHT_8K",
+  KrispInitErrorWeight16k: "NoiseCancellerError.KRISP_INIT_ERROR_WEIGHT_16K",
+  KrispInitErrorWeight32k: "NoiseCancellerError.KRISP_INIT_ERROR_WEIGHT_32K",
+  KrispInitErrorWeightVad: "NoiseCancellerError.KRISP_INIT_ERROR_WEIGHT_VAD",
+  VideoBackgroundUnsupported: "VideoBackgroundError.UNSUPPORTED",
+  VideoBackgroundInitFailed: "VideoBackgroundError.INIT_FAILED"
+};
+c5776_1 = void 0;
+let c5776_0 = Object.values(c5775_5).map((item) => item.errorCode);
+if (c5776_0.length !== new Set(c5776_0).size) {
+  c5776_1 = c5776_0.filter((item, index) => c5776_0.indexOf(item) !== index);
+  throw new Error(`Duplicate AV error codes found:
+${Object.entries(c5775_5).filter((item) => {
+  const [, r22] = item;
+  return c5776_1.includes(r22.errorCode);
+}).map((item) => {
+  const [r7, r24] = item;
+  return `${r7}: ${r24.errorCode}`;
+}).join("\n")}`);
+}
+export { r10 as AVError };
+export { r9 as AVErrorCategory };
+export { r56 as AVErrorSeverity };
+export { r157 as AVUnderlyingError };
+export function reportAVError(a0) {
+  const type = a0.type;
+  c5775_4.error(`AV error reported: ${type} ${JSON.stringify(_objectWithoutProperties(a0, _excluded))}`);
+  const r20 = c5775_5[type];
+  Dispatcher.dispatch({
+    type: "REPORT_AV_ERROR",
+    error: type,
+    errorCode: r20.errorCode,
+    severity: r20.severity,
+    category: r20.category,
+    context: a0
+  });
+}
+export function getErrorInfo(a0) {
+  return c5775_5[a0];
+}

modules/errors/av_errors/AVErrorAnalytics.tsx

@@ -0,0 +1,742 @@
+// Metro module 16692 (f16693).
+import MediaEngineStatsStore from "../../media_engine/MediaEngineStatsStore";
+import { getSystemAnalyticsInfo } from "../../system_analytics/SystemAnalyticsStore.native";
+import ApplicationStreamingSettingsStore from "../../../stores/ApplicationStreamingSettingsStore";
+import ChannelStore from "../../../stores/ChannelStore";
+import MediaEngineStore from "../../../stores/MediaEngineStore";
+import RTCConnectionStore from "../../../stores/RTCConnectionStore";
+import RTCRegionStore from "../../../stores/RTCRegionStore";
+import SelectedChannelStore from "../../../stores/SelectedChannelStore";
+import StreamRTCConnectionStore from "../../../stores/StreamRTCConnectionStore";
+import { AnalyticEvents } from "../../../Constants";
+import { MediaEngineContextTypes, SIMULCAST_HQ_QUALITY } from "../../../_bundle/Module4250";
+import { getErrorInfo } from "./AVError";
+import { decodeStreamKey } from "../../go_live/utils/StreamKeyUtils";
+import { getRunningGameAnalytics } from "../../game_detection/GameAnalyticsUtils";
+import Module12 from "../../../_bundle/Module12";
+import { parseCodecType, parseEncoder, parseDecoder } from "../../../lib/VideoQualityStats";
+import { WindowVisibilityVideoManager } from "../../../lib/WindowVisibilityVideoManager";
+import ProcessUtils_native from "../../../utils/ProcessUtils.native";
+import CrossPlatformNativeUtils_native from "../../../utils/CrossPlatformNativeUtils.native";
+import AnalyticsUtils from "../../../utils/AnalyticsUtils";
+function $mk100320() {
+  return (a0) => a0.type === "video";
+}
+function $mk100321() {
+  return (a0) => a0.type === "video";
+}
+const getCurrentScreenshareCaptureMethod = function getCurrentScreenshareCaptureMethod(a0) {
+  const connectionStats = MediaEngineStatsStore.getConnectionStats(a0);
+  const lastConnectionStats = MediaEngineStatsStore.getLastConnectionStats(a0);
+  if (connectionStats != null && lastConnectionStats != null) {
+    const r6 = {};
+    for (const item of ["videohookFrames", "hybridDxgiFrames", "hybridGdiFrames", "hybridVideohookFrames", "hybridGraphicsCaptureFrames", "hybridGdiBitBltFrames", "hybridGdiPrintWindowFrames", "quartzFrames", "screenCaptureKitFrames"]) {
+      const screenshare = lastConnectionStats.stats.screenshare;
+      let r40 = screenshare == null ? void 0 : screenshare[item];
+      if (r40 == null) {
+        r40 = 0;
+      }
+      const r42 = r40;
+      const screenshare2 = connectionStats.stats.screenshare;
+      let r46 = screenshare2 == null ? void 0 : screenshare2[item];
+      if (r46 == null) {
+        r46 = 0;
+      }
+      r6[item] = r46 - r42;
+    }
+    let r52 = -1;
+    let r53 = null;
+    for (const item2 of Object.entries(r6)) {
+      const [r67, r68] = item2;
+      if (r68 > r52) {
+        r52 = r68;
+        r53 = r67;
+      }
+    }
+    return r52 > 0 ? r53 : null;
+  }
+  return null;
+};
+export function sendAVErrorAnalyticsEvent(a0, a1) {
+  let r104, r118;
+  let c23377_1;
+  let c23377_0 = a0;
+  const errorInfo = getErrorInfo(a0);
+  const voiceChannelId = SelectedChannelStore.getVoiceChannelId();
+  let r10 = "channelId" in a1 ? a1.channelId : void 0;
+  if (r10 == null) {
+    r10 = voiceChannelId;
+  }
+  if (r10 == null) {
+    r10 = null;
+  }
+  let c23377_3 = r10;
+  const channel = ChannelStore.getChannel(r10);
+  const r28 = "streamKey" in a1 ? a1.streamKey : void 0;
+  let r31 = "mediaContext" in a1 ? a1.mediaContext : void 0;
+  const mediaContext = r31;
+  const underlyingError = "underlyingError" in a1 ? a1.underlyingError : void 0;
+  const errorMessage = "errorMessage" in a1 ? a1.errorMessage : void 0;
+  const mediaSessionId = "mediaSessionId" in a1 ? a1.mediaSessionId : void 0;
+  const rtcConnectionId = "rtcConnectionId" in a1 ? a1.rtcConnectionId : void 0;
+  const videoCodec = "videoCodec" in a1 ? a1.videoCodec : void 0;
+  const videoEncoder = "videoEncoder" in a1 ? a1.videoEncoder : void 0;
+  const videoDecoder = "videoDecoder" in a1 ? a1.videoDecoder : void 0;
+  const audioCaptureSampleRateMismatchPercent = "audioCaptureSampleRateMismatchPercent" in a1 ? a1.audioCaptureSampleRateMismatchPercent : void 0;
+  const audioInputDeviceName = "audioInputDeviceName" in a1 ? a1.audioInputDeviceName : void 0;
+  const audioOutputDeviceName = "audioOutputDeviceName" in a1 ? a1.audioOutputDeviceName : void 0;
+  const videoDeviceName = "videoDeviceName" in a1 ? a1.videoDeviceName : void 0;
+  let r12 = "userId" in a1 ? a1.userId : void 0;
+  const r68 = r28 != null ? decodeStreamKey(r28) : null;
+  let c23377_17 = r68;
+  const rTCConnection = r28 != null ? StreamRTCConnectionStore.getRTCConnection(r28) : null;
+  const rTCConnection2 = r28 == null ? RTCConnectionStore.getRTCConnection() : rTCConnection;
+  const r77 = r28 != null ? rTCConnection == null ? void 0 : rTCConnection.analyticsContext?.streamApplication : null;
+  const state = ApplicationStreamingSettingsStore.getState();
+  const { resolution, fps } = state;
+  const runningGameAnalytics = getRunningGameAnalytics(r77);
+  const { gameName, gameId, exe, distributor } = runningGameAnalytics;
+  const isErrorOutbound = errorInfo.isErrorOutbound;
+  if (mediaContext == null) {
+    r31 = MediaEngineContextTypes.DEFAULT;
+  }
+  const DEFAULT = r31;
+  if (r68 != null) {
+    r12 = r68.ownerId;
+  }
+  const ownerId = r12;
+  const voiceParticipantType = rTCConnection != null ? rTCConnection == null ? void 0 : rTCConnection.getVoiceParticipantType() : isErrorOutbound ? "sender" : "receiver";
+  let r101 = rTCConnection2 == null ? void 0 : rTCConnection2.getMediaEngineConnectionId();
+  if (r101 == null) {
+    r101 = null;
+  }
+  let c23377_30 = r101;
+  if (r28 != null && r68 != null) {
+    const r117 = rTCConnection2 == null;
+    if (isErrorOutbound) {
+      let r121 = void 0;
+      if (!r117) {
+        const outboundStats = rTCConnection2.getOutboundStats();
+        r121 = outboundStats == null ? void 0 : outboundStats.find((outboundStat) => outboundStat.quality === SIMULCAST_HQ_QUALITY);
+      }
+      r118 = r121;
+    } else {
+      r118 = r117 ? void 0 : rTCConnection2.getInboundStats(r68.ownerId);
+    }
+    r104 = r118;
+  } else if (isErrorOutbound) {
+    let r113 = rTCConnection2 == null ? void 0 : rTCConnection2.getOutboundStats();
+    if (r113 == null) {
+      r113 = [];
+    }
+    let r116 = Module12.maxBy(r113, (a0) => a0.num_frames);
+    if (r116 == null) {
+      r116 = null;
+    }
+    r104 = r116;
+  } else {
+    r104 = ownerId != null ? rTCConnection2 == null ? void 0 : rTCConnection2.getInboundStats(ownerId) : null;
+  }
+  c23377_1 = r104;
+  getSystemAnalyticsInfo().then((result) => {
+    let r73, r104, r181, fps2;
+    const r7 = {
+      error_name: c23377_0.valueOf(),
+      error_code: errorInfo.errorCode,
+      error_severity: errorInfo.severity,
+      error_category: errorInfo.category,
+      underlying_error: null,
+      error_message: null,
+      guild_id: null,
+      channel_id: null,
+      channel_type: null,
+      rtc_connection_id: null,
+      media_session_id: null,
+      parent_media_session_id: null,
+      context: null,
+      voice_backend_version: null,
+      rtc_worker_backend_version: null,
+      guild_region: null,
+      hostname: null,
+      duration: null,
+      participant_type: null,
+      num_frames: null,
+      num_packets: null,
+      num_bytes: null,
+      num_packets_lost: null,
+      video_codec: null,
+      video_encoder: null,
+      video_decoder: null,
+      audio_capture_sample_rate_mismatch_percent: null,
+      incoming_video_stopped_for_occlusion: null,
+      bitrate: null,
+      target_bitrate: null,
+      fps: null,
+      target_fps: null,
+      sender_user_id: null,
+      stream_region: null,
+      stream_source_type: null,
+      num_stream_viewers: null,
+      video_input_resolution_height: null,
+      video_input_frame_rate: null,
+      screenshare_capture_method: null,
+      share_application_name: null,
+      share_application_id: null,
+      share_application_executable: null,
+      share_application_distributor: null,
+      cpu_brand: null,
+      cpu_vendor: null,
+      cpu_memory: null,
+      gpu_brand: null,
+      gpu_count: null,
+      gpu_memory: null,
+      gpu_device_vendor_id: null,
+      gpu_device_device_id: null,
+      gpu_device_sub_sys_id: null,
+      gpu_device_revision: null,
+      gpu_driver_version: null,
+      cpu_usage: null,
+      memory_usage: null,
+      outbound_bitrate_estimate: null,
+      inbound_bitrate_estimate: null,
+      hardware_enabled: null,
+      audio_input_device_name: null,
+      audio_output_device_name: null,
+      video_device_name: null,
+      audio_subsystem: null,
+      automatic_audio_subsystem: null,
+      audio_layer: null,
+      audio_input_mode: null,
+      automatic_audio_input_sensitivity_enabled: null,
+      audio_input_sensitivity: null,
+      echo_cancellation_enabled: null,
+      noise_suppression_enabled: null,
+      noise_cancellation_enabled: null,
+      automatic_gain_control_enabled: null,
+      sidechain_compression_enabled: null,
+      input_volume: null,
+      output_volume: null,
+      audio_input_device_count: null,
+      audio_output_device_count: null,
+      app_hardware_acceleration_enabled: null,
+      input_device_os_muted: null,
+      input_device_os_volume: null
+    };
+    let underlying_error = underlyingError;
+    if (underlyingError == null) {
+      underlying_error = null;
+    }
+    r7.underlying_error = underlying_error;
+    let error_message = errorMessage;
+    if (errorMessage == null) {
+      error_message = null;
+    }
+    r7.error_message = error_message;
+    let guild_id = channel?.guild_id;
+    if (guild_id == null) {
+      guild_id = null;
+    }
+    r7.guild_id = guild_id;
+    let channel_id = c23377_3;
+    if (channel_id == null) {
+      channel_id = null;
+    }
+    r7.channel_id = channel_id;
+    let channel_type = channel?.type;
+    if (channel_type == null) {
+      channel_type = null;
+    }
+    r7.channel_type = channel_type;
+    let rtc_connection_id = rtcConnectionId;
+    if (rtcConnectionId == null) {
+      rtc_connection_id = null;
+    }
+    r7.rtc_connection_id = rtc_connection_id;
+    let media_session_id = mediaSessionId;
+    if (mediaSessionId == null) {
+      media_session_id = RTCConnectionStore.getMediaSessionId();
+    }
+    if (media_session_id == null) {
+      media_session_id = null;
+    }
+    r7.media_session_id = media_session_id;
+    let parent_media_session_id = rTCConnection?.parentMediaSessionId;
+    if (parent_media_session_id == null) {
+      parent_media_session_id = null;
+    }
+    r7.parent_media_session_id = parent_media_session_id;
+    let context = mediaContext;
+    if (mediaContext == null) {
+      context = null;
+    }
+    r7.context = context;
+    const rTCConnection3 = RTCConnectionStore.getRTCConnection();
+    let voice_backend_version = rTCConnection3 == null ? void 0 : rTCConnection3.getVoiceVersion();
+    if (voice_backend_version == null) {
+      voice_backend_version = null;
+    }
+    r7.voice_backend_version = voice_backend_version;
+    const rTCConnection4 = RTCConnectionStore.getRTCConnection();
+    let rtc_worker_backend_version = rTCConnection4 == null ? void 0 : rTCConnection4.getRtcWorkerVersion();
+    if (rtc_worker_backend_version == null) {
+      rtc_worker_backend_version = null;
+    }
+    r7.rtc_worker_backend_version = rtc_worker_backend_version;
+    let guild_region = RTCRegionStore.getRegion(RTCConnectionStore.getHostname());
+    if (guild_region == null) {
+      guild_region = null;
+    }
+    r7.guild_region = guild_region;
+    let hostname = RTCConnectionStore.getHostname();
+    if (hostname == null) {
+      hostname = null;
+    }
+    r7.hostname = hostname;
+    let duration = rTCConnection2 == null ? void 0 : rTCConnection2.getDurationSeconds();
+    if (duration == null) {
+      duration = null;
+    }
+    r7.duration = duration;
+    let participant_type = voiceParticipantType;
+    if (voiceParticipantType == null) {
+      participant_type = null;
+    }
+    r7.participant_type = participant_type;
+    let num_frames = c23377_1?.num_frames;
+    if (num_frames == null) {
+      num_frames = 0;
+    }
+    r7.num_frames = num_frames;
+    let num_packets = c23377_1?.num_packets;
+    if (num_packets == null) {
+      num_packets = 0;
+    }
+    r7.num_packets = num_packets;
+    let num_bytes = c23377_1?.num_bytes;
+    if (num_bytes == null) {
+      num_bytes = 0;
+    }
+    r7.num_bytes = num_bytes;
+    if (isErrorOutbound) {
+      const connectionStats2 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+      const r87 = connectionStats2 == null;
+      let r88 = null;
+      if (!r87) {
+        let r94 = connectionStats2.stats.rtp.outbound.find($mk100320());
+        if (r94 == null) {
+          r94 = null;
+        }
+        r88 = r94;
+      }
+      r73 = r88;
+    } else {
+      const r72 = ownerId == null;
+      r73 = null;
+      if (!r72) {
+        const connectionStats = MediaEngineStatsStore.getConnectionStats(c23377_30);
+        const r76 = connectionStats == null;
+        r73 = null;
+        if (!r76) {
+          const r15 = connectionStats.stats.rtp.inbound[ownerId];
+          const r80 = r15 == null;
+          let r81 = null;
+          if (!r80) {
+            let r83 = r15.find($mk100321());
+            if (r83 == null) {
+              r83 = null;
+            }
+            r81 = r83;
+          }
+          r73 = r81;
+        }
+      }
+    }
+    let num_packets_lost = r73?.packetsLost;
+    if (num_packets_lost == null) {
+      num_packets_lost = 0;
+    }
+    r7.num_packets_lost = num_packets_lost;
+    let video_codec = videoCodec;
+    if (videoCodec == null) {
+      if (isErrorOutbound) {
+        const connectionStats4 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+        const r118 = connectionStats4 == null;
+        let r119 = null;
+        if (!r118) {
+          let r125 = connectionStats4.stats.rtp.outbound.find($mk100320());
+          if (r125 == null) {
+            r125 = null;
+          }
+          r119 = r125;
+        }
+        r104 = r119;
+      } else {
+        const r103 = ownerId == null;
+        r104 = null;
+        if (!r103) {
+          const connectionStats3 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+          const r107 = connectionStats3 == null;
+          r104 = null;
+          if (!r107) {
+            const r18 = connectionStats3.stats.rtp.inbound[ownerId];
+            const r111 = r18 == null;
+            let r112 = null;
+            if (!r111) {
+              let r114 = r18.find($mk100321());
+              if (r114 == null) {
+                r114 = null;
+              }
+              r112 = r114;
+            }
+            r104 = r112;
+          }
+        }
+      }
+      video_codec = parseCodecType(r104 == null ? void 0 : r104.codec.name);
+    }
+    if (video_codec == null) {
+      video_codec = null;
+    }
+    r7.video_codec = video_codec;
+    let video_encoder = videoEncoder;
+    if (videoEncoder == null) {
+      const connectionStats5 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+      const r138 = connectionStats5 == null;
+      let r139 = null;
+      if (!r138) {
+        let r145 = connectionStats5.stats.rtp.outbound.find($mk100320());
+        if (r145 == null) {
+          r145 = null;
+        }
+        r139 = r145;
+      }
+      video_encoder = parseEncoder(r139?.encoderImplementationName);
+    }
+    if (video_encoder == null) {
+      video_encoder = null;
+    }
+    r7.video_encoder = video_encoder;
+    let video_decoder = videoDecoder;
+    if (videoDecoder == null) {
+      const r154 = ownerId == null;
+      let r155 = null;
+      if (!r154) {
+        const connectionStats6 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+        const r159 = connectionStats6 == null;
+        r155 = null;
+        if (!r159) {
+          const r163 = connectionStats6.stats.rtp.inbound[ownerId];
+          const r164 = r163 == null;
+          let r165 = null;
+          if (!r164) {
+            let r168 = r163.find($mk100321());
+            if (r168 == null) {
+              r168 = null;
+            }
+            r165 = r168;
+          }
+          r155 = r165;
+        }
+      }
+      video_decoder = parseDecoder(r155?.decoderImplementationName);
+    }
+    if (video_decoder == null) {
+      video_decoder = null;
+    }
+    r7.video_decoder = video_decoder;
+    let audio_capture_sample_rate_mismatch_percent = audioCaptureSampleRateMismatchPercent;
+    if (audioCaptureSampleRateMismatchPercent == null) {
+      audio_capture_sample_rate_mismatch_percent = null;
+    }
+    r7.audio_capture_sample_rate_mismatch_percent = audio_capture_sample_rate_mismatch_percent;
+    r7.incoming_video_stopped_for_occlusion = !WindowVisibilityVideoManager.isIncomingVideoEnabled();
+    if (isErrorOutbound) {
+      const connectionStats8 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+      const r198 = connectionStats8 == null;
+      let r199 = null;
+      if (!r198) {
+        let r205 = connectionStats8.stats.rtp.outbound.find($mk100320());
+        if (r205 == null) {
+          r205 = null;
+        }
+        r199 = r205;
+      }
+      r181 = r199;
+    } else {
+      const r180 = ownerId == null;
+      r181 = null;
+      if (!r180) {
+        const connectionStats7 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+        const r185 = connectionStats7 == null;
+        r181 = null;
+        if (!r185) {
+          const r189 = connectionStats7.stats.rtp.inbound[ownerId];
+          const r190 = r189 == null;
+          let r191 = null;
+          if (!r190) {
+            let r194 = r189.find($mk100321());
+            if (r194 == null) {
+              r194 = null;
+            }
+            r191 = r194;
+          }
+          r181 = r191;
+        }
+      }
+    }
+    let bitrate = r181?.bitrate;
+    if (bitrate == null) {
+      bitrate = null;
+    }
+    r7.bitrate = bitrate;
+    let target_bitrate = null;
+    if (isErrorOutbound) {
+      const connectionStats9 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+      const r212 = connectionStats9 == null;
+      let r213 = null;
+      if (!r212) {
+        let r219 = connectionStats9.stats.rtp.outbound.find($mk100320());
+        if (r219 == null) {
+          r219 = null;
+        }
+        r213 = r219;
+      }
+      let r221 = r213?.bitrateTarget;
+      if (r221 == null) {
+        r221 = null;
+      }
+      target_bitrate = r221;
+    }
+    r7.target_bitrate = target_bitrate;
+    if (isErrorOutbound) {
+      const connectionStats11 = MediaEngineStatsStore.getConnectionStats(DEFAULT);
+      const r243 = connectionStats11 == null;
+      let r244 = null;
+      if (!r243) {
+        let r250 = connectionStats11.stats.rtp.outbound.find($mk100320());
+        if (r250 == null) {
+          r250 = null;
+        }
+        r244 = r250;
+      }
+      let r252 = r244?.frameRateEncode;
+      if (r252 == null) {
+        r252 = null;
+      }
+      fps2 = r252;
+    } else {
+      const r223 = ownerId == null;
+      let r224 = null;
+      if (!r223) {
+        const connectionStats10 = MediaEngineStatsStore.getConnectionStats(DEFAULT);
+        const r228 = connectionStats10 == null;
+        r224 = null;
+        if (!r228) {
+          const r232 = connectionStats10.stats.rtp.inbound[ownerId];
+          const r233 = r232 == null;
+          let r234 = null;
+          if (!r233) {
+            let r237 = r232.find($mk100321());
+            if (r237 == null) {
+              r237 = null;
+            }
+            r234 = r237;
+          }
+          r224 = r234;
+        }
+      }
+      fps2 = r224?.frameRateDecode;
+      if (fps2 == null) {
+        fps2 = null;
+      }
+    }
+    if (fps2 == null) {
+      fps2 = null;
+    }
+    r7.fps = fps2;
+    r7.target_fps = DEFAULT === MediaEngineContextTypes.STREAM ? isErrorOutbound ? fps : null : null;
+    let sender_user_id = c23377_17?.ownerId;
+    if (sender_user_id == null) {
+      sender_user_id = null;
+    }
+    r7.sender_user_id = sender_user_id;
+    let stream_region = rTCConnection == null ? void 0 : rTCConnection.getRegion();
+    if (stream_region == null) {
+      stream_region = null;
+    }
+    r7.stream_region = stream_region;
+    let stream_source_type = null;
+    if (isErrorOutbound) {
+      let r264 = rTCConnection == null ? void 0 : rTCConnection.analyticsContext?.streamSourceType;
+      if (r264 == null) {
+        r264 = null;
+      }
+      stream_source_type = r264;
+    }
+    r7.stream_source_type = stream_source_type;
+    let num_stream_viewers = rTCConnection == null ? void 0 : rTCConnection.analyticsContext?.numViewers;
+    if (num_stream_viewers == null) {
+      num_stream_viewers = null;
+    }
+    r7.num_stream_viewers = num_stream_viewers;
+    let video_input_resolution_height = null;
+    if (isErrorOutbound) {
+      let r272 = resolution;
+      if (resolution == null) {
+        r272 = null;
+      }
+      video_input_resolution_height = r272;
+    }
+    r7.video_input_resolution_height = video_input_resolution_height;
+    let video_input_frame_rate = null;
+    if (isErrorOutbound) {
+      let r274 = fps;
+      if (fps == null) {
+        r274 = null;
+      }
+      video_input_frame_rate = r274;
+    }
+    r7.video_input_frame_rate = video_input_frame_rate;
+    r7.screenshare_capture_method = getCurrentScreenshareCaptureMethod(c23377_30);
+    let share_application_name = gameName;
+    if (gameName == null) {
+      share_application_name = null;
+    }
+    r7.share_application_name = share_application_name;
+    let share_application_id = gameId;
+    if (gameId == null) {
+      share_application_id = null;
+    }
+    r7.share_application_id = share_application_id;
+    let share_application_executable = exe;
+    if (exe == null) {
+      share_application_executable = null;
+    }
+    r7.share_application_executable = share_application_executable;
+    let share_application_distributor = distributor;
+    if (distributor == null) {
+      share_application_distributor = null;
+    }
+    r7.share_application_distributor = share_application_distributor;
+    let cpu_brand = result?.cpu_brand;
+    if (cpu_brand == null) {
+      cpu_brand = null;
+    }
+    r7.cpu_brand = cpu_brand;
+    let cpu_vendor = result?.cpu_vendor;
+    if (cpu_vendor == null) {
+      cpu_vendor = null;
+    }
+    r7.cpu_vendor = cpu_vendor;
+    let cpu_memory = result?.cpu_memory;
+    if (cpu_memory == null) {
+      cpu_memory = null;
+    }
+    r7.cpu_memory = cpu_memory;
+    let gpu_brand = result?.gpu_brand;
+    if (gpu_brand == null) {
+      gpu_brand = null;
+    }
+    r7.gpu_brand = gpu_brand;
+    let gpu_count = result?.gpu_count;
+    if (gpu_count == null) {
+      gpu_count = null;
+    }
+    r7.gpu_count = gpu_count;
+    let gpu_memory = result?.gpu_memory;
+    if (gpu_memory == null) {
+      gpu_memory = null;
+    }
+    r7.gpu_memory = gpu_memory;
+    let gpu_device_vendor_id = result?.gpu_device_vendor_id;
+    if (gpu_device_vendor_id == null) {
+      gpu_device_vendor_id = null;
+    }
+    r7.gpu_device_vendor_id = gpu_device_vendor_id;
+    let gpu_device_device_id = result?.gpu_device_device_id;
+    if (gpu_device_device_id == null) {
+      gpu_device_device_id = null;
+    }
+    r7.gpu_device_device_id = gpu_device_device_id;
+    let gpu_device_sub_sys_id = result?.gpu_device_sub_sys_id;
+    if (gpu_device_sub_sys_id == null) {
+      gpu_device_sub_sys_id = null;
+    }
+    r7.gpu_device_sub_sys_id = gpu_device_sub_sys_id;
+    let gpu_device_revision = result?.gpu_device_revision;
+    if (gpu_device_revision == null) {
+      gpu_device_revision = null;
+    }
+    r7.gpu_device_revision = gpu_device_revision;
+    let gpu_driver_version = result?.gpu_driver_version;
+    if (gpu_driver_version == null) {
+      gpu_driver_version = null;
+    }
+    r7.gpu_driver_version = gpu_driver_version;
+    let cpu_usage = ProcessUtils_native.getCurrentCPUUsagePercent();
+    if (cpu_usage == null) {
+      cpu_usage = null;
+    }
+    r7.cpu_usage = cpu_usage;
+    let memory_usage = ProcessUtils_native.getCurrentMemoryUsageKB();
+    if (memory_usage == null) {
+      memory_usage = null;
+    }
+    r7.memory_usage = memory_usage;
+    const connectionStats12 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+    let outbound_bitrate_estimate = connectionStats12 == null ? void 0 : connectionStats12.stats.transport.outboundBitrateEstimate;
+    if (outbound_bitrate_estimate == null) {
+      outbound_bitrate_estimate = null;
+    }
+    r7.outbound_bitrate_estimate = outbound_bitrate_estimate;
+    const connectionStats13 = MediaEngineStatsStore.getConnectionStats(c23377_30);
+    let inbound_bitrate_estimate = connectionStats13 == null ? void 0 : connectionStats13.stats.transport.inboundBitrateEstimate;
+    if (inbound_bitrate_estimate == null) {
+      inbound_bitrate_estimate = null;
+    }
+    r7.inbound_bitrate_estimate = inbound_bitrate_estimate;
+    r7.hardware_enabled = MediaEngineStore.getHardwareEncoding();
+    let audio_input_device_name = audioInputDeviceName;
+    if (audioInputDeviceName == null) {
+      audio_input_device_name = MediaEngineStore.getInputDevices()[MediaEngineStore.getInputDeviceId()]?.name;
+    }
+    r7.audio_input_device_name = audio_input_device_name;
+    let audio_output_device_name = audioOutputDeviceName;
+    if (audioOutputDeviceName == null) {
+      audio_output_device_name = MediaEngineStore.getOutputDevices()[MediaEngineStore.getOutputDeviceId()]?.name;
+    }
+    r7.audio_output_device_name = audio_output_device_name;
+    let video_device_name = videoDeviceName;
+    if (videoDeviceName == null) {
+      video_device_name = MediaEngineStore.getVideoDevices()[MediaEngineStore.getVideoDeviceId()]?.name;
+    }
+    r7.video_device_name = video_device_name;
+    r7.audio_subsystem = MediaEngineStore.getMediaEngine().getAudioSubsystem();
+    r7.automatic_audio_subsystem = MediaEngineStore.getSettings().automaticAudioSubsystem;
+    r7.audio_layer = MediaEngineStore.getMediaEngine().getAudioLayer();
+    r7.audio_input_mode = MediaEngineStore.getSettings().mode;
+    r7.automatic_audio_input_sensitivity_enabled = MediaEngineStore.getSettings().modeOptions.autoThreshold;
+    r7.audio_input_sensitivity = MediaEngineStore.getSettings().modeOptions.threshold;
+    r7.echo_cancellation_enabled = MediaEngineStore.getEchoCancellation();
+    r7.noise_suppression_enabled = MediaEngineStore.getNoiseSuppression();
+    r7.noise_cancellation_enabled = MediaEngineStore.getNoiseCancellation();
+    r7.automatic_gain_control_enabled = MediaEngineStore.getAutomaticGainControl();
+    r7.sidechain_compression_enabled = MediaEngineStore.getSidechainCompression();
+    r7.input_volume = MediaEngineStore.getInputVolume();
+    r7.output_volume = MediaEngineStore.getOutputVolume();
+    r7.audio_input_device_count = Object.keys(MediaEngineStore.getInputDevices()).length;
+    r7.audio_output_device_count = Object.keys(MediaEngineStore.getOutputDevices()).length;
+    r7.app_hardware_acceleration_enabled = CrossPlatformNativeUtils_native.getAppHardwareAccelerationEnabled();
+    let input_device_os_muted = MediaEngineStore.getInputDeviceOSMuted();
+    if (input_device_os_muted == null) {
+      input_device_os_muted = null;
+    }
+    r7.input_device_os_muted = input_device_os_muted;
+    let input_device_os_volume = MediaEngineStore.getInputDeviceOSVolume();
+    if (input_device_os_volume == null) {
+      input_device_os_volume = null;
+    }
+    r7.input_device_os_volume = input_device_os_volume;
+    AnalyticsUtils.track(AnalyticEvents.AV_ERROR_REPORTED, r7);
+  });
+}

modules/errors/av_errors/AVErrorContext.tsx

@@ -0,0 +1,59 @@
+// Metro module 16674 (f16675).
+import MediaEngineStore from "../../../stores/MediaEngineStore";
+import RTCConnectionStore from "../../../stores/RTCConnectionStore";
+import SelectedChannelStore from "../../../stores/SelectedChannelStore";
+import StreamRTCConnectionStore from "../../../stores/StreamRTCConnectionStore";
+import { MediaEngineContextTypes } from "../../../_bundle/Module4286";
+import { decodeStreamKey } from "../../go_live/utils/StreamKeyUtils";
+export function getVoiceChannelErrorContext() {
+  let channelId = SelectedChannelStore.getVoiceChannelId();
+  if (channelId == null) {
+    channelId = void 0;
+  }
+  let mediaSessionId = RTCConnectionStore.getMediaSessionId();
+  if (mediaSessionId == null) {
+    mediaSessionId = void 0;
+  }
+  const r11 = {
+    channelId,
+    mediaSessionId,
+    rtcConnectionId: RTCConnectionStore.getRTCConnectionId(),
+    mediaContext: MediaEngineContextTypes.DEFAULT,
+    ...{
+      videoDeviceName: MediaEngineStore.getVideoDevices()[MediaEngineStore.getVideoDeviceId()]?.name,
+      audioInputDeviceName: MediaEngineStore.getInputDevices()[MediaEngineStore.getInputDeviceId()]?.name,
+      audioOutputDeviceName: MediaEngineStore.getOutputDevices()[MediaEngineStore.getOutputDeviceId()]?.name
+    }
+  };
+  return r11;
+}
+export function getStreamErrorContext(a0) {
+  const r15 = decodeStreamKey(a0);
+  const { channelId, ownerId } = r15;
+  const rTCConnection = StreamRTCConnectionStore.getRTCConnection(a0);
+  let mediaSessionId = rTCConnection == null ? void 0 : rTCConnection.getMediaSessionId();
+  if (mediaSessionId == null) {
+    mediaSessionId = void 0;
+  }
+  const r18 = {
+    channelId,
+    mediaSessionId,
+    rtcConnectionId: rTCConnection == null ? void 0 : rTCConnection.getRTCConnectionId(),
+    mediaContext: MediaEngineContextTypes.STREAM,
+    streamKey: a0,
+    userId: ownerId,
+    ...{
+      videoDeviceName: MediaEngineStore.getVideoDevices()[MediaEngineStore.getVideoDeviceId()]?.name,
+      audioInputDeviceName: MediaEngineStore.getInputDevices()[MediaEngineStore.getInputDeviceId()]?.name,
+      audioOutputDeviceName: MediaEngineStore.getOutputDevices()[MediaEngineStore.getOutputDeviceId()]?.name
+    }
+  };
+  return r18;
+}
+export function getCommonErrorContext() {
+  return {
+    videoDeviceName: MediaEngineStore.getVideoDevices()[MediaEngineStore.getVideoDeviceId()]?.name,
+    audioInputDeviceName: MediaEngineStore.getInputDevices()[MediaEngineStore.getInputDeviceId()]?.name,
+    audioOutputDeviceName: MediaEngineStore.getOutputDevices()[MediaEngineStore.getOutputDeviceId()]?.name
+  };
+}

modules/errors/av_errors/AVErrorManager.tsx

@@ -0,0 +1,123 @@
+// Metro module 16671 (f16672).
+import _objectWithoutProperties from "../../../_bundle/_objectWithoutProperties";
+import ApplicationStreamingStore from "../../../stores/ApplicationStreamingStore";
+import SelectedChannelStore from "../../../stores/SelectedChannelStore";
+import VoiceStateStore from "../../../stores/VoiceStateStore";
+import AVErrorStore from "./AVErrorStore";
+import Logger from "../../debug/Logger";
+import { ErrorDefinitions } from "./definitions/index";
+import AutomaticLifecycleManager from "../../../lib/AutomaticLifecycleManager";
+import { reportAVError } from "./AVError";
+import Dispatcher from "../../../Dispatcher";
+import { sendAVErrorAnalyticsEvent } from "./AVErrorAnalytics";
+let _excluded, c12006_9, makeErrorKey;
+const setDifference = function setDifference(a0, a1) {
+  const set = new Set();
+  for (const item of a0) {
+    if (!a1.has(item)) {
+      set.add(item);
+    }
+  }
+  return set;
+};
+makeErrorKey = function makeErrorKey(item2) {
+  const r12 = ErrorDefinitions[item2.type];
+  return `${item2.type}:${r12 == null ? void 0 : r12.makeErrorContextKey(item2)}`;
+};
+_excluded = ["type"];
+c12006_9 = new Logger("AVErrorManager");
+class AVErrorManager extends AutomaticLifecycleManager {
+  actions = {
+    MEDIA_ENGINE_SET_AUDIO_ENABLED: this.updateActiveErrors,
+    AUDIO_INPUT_DETECTED: this.updateActiveErrors,
+    AUDIO_SET_DISPLAY_SILENCE_WARNING: this.updateActiveErrors,
+    CERTIFIED_DEVICES_SET: this.updateActiveErrors,
+    AUDIO_SET_INPUT_DEVICE: this.updateActiveErrors,
+    AUDIO_SET_OUTPUT_DEVICE: this.updateActiveErrors,
+    MEDIA_ENGINE_DEVICES: this.updateActiveErrors,
+    RTC_CONNECTION_STATE: this.updateActiveErrors,
+    VOICE_STATE_UPDATES: this.updateActiveErrors,
+    MEDIA_ENGINE_SET_GO_LIVE_SOURCE: this.updateActiveErrors,
+    MEDIA_ENGINE_SOUNDSHARE_FAILED: this.updateActiveErrors,
+    MEDIA_ENGINE_NOISE_CANCELLATION_ERROR: this.updateActiveErrors,
+    MEDIA_ENGINE_VOICE_ACTIVITY_DETECTION_ERROR: this.updateActiveErrors,
+    MEDIA_ENGINE_VIDEO_FILTER_ERROR: this.updateActiveErrors,
+    MEDIA_ENGINE_VIDEO_STATE_CHANGED: this.updateActiveErrors,
+    NATIVE_SCREEN_SHARE_PICKER_UPDATE: this.updateActiveErrors,
+    NATIVE_SCREEN_SHARE_PICKER_ERROR: this.updateActiveErrors,
+    MEDIA_SESSION_JOINED: this.updateActiveErrors,
+    RTC_CONNECTION_UPDATE_ID: this.updateActiveErrors,
+    RTC_CONNECTION_VIDEO: this.updateActiveErrors,
+    RTC_CONNECTION_REMOTE_VIDEO_SINK_WANTS: this.updateActiveErrors,
+    VIDEO_STREAM_READY_TIMEOUT: this.updateActiveErrors,
+    CLEAR_VIDEO_STREAM_READY_TIMEOUT: this.updateActiveErrors,
+    REPORT_AV_ERROR: this.handleReportAVError,
+    STREAM_CLOSE: this.updateActiveErrors
+  };
+  updateActiveErrors() {
+    let voiceChannelId = SelectedChannelStore.getVoiceChannelId();
+    if (voiceChannelId == null) {
+      voiceChannelId = null;
+    }
+    const r35 = voiceChannelId != null;
+    let voiceState = null;
+    if (r35) {
+      let r38 = VoiceStateStore.getVoiceStateForChannel(voiceChannelId);
+      if (r38 == null) {
+        r38 = null;
+      }
+      voiceState = r38;
+    }
+    const allActiveStreams = ApplicationStreamingStore.getAllActiveStreams();
+    const map = new Map();
+    for (const item of Object.values(ErrorDefinitions)) {
+      const activeErrors = item.getActiveErrors({
+        voiceChannelId,
+        voiceState,
+        activeStreams: allActiveStreams
+      });
+      if (activeErrors != null) {
+        for (const item2 of activeErrors) {
+          map.set(makeErrorKey(item2), item2);
+        }
+      }
+    }
+    L37: {
+      const activeErrors2 = AVErrorStore.getActiveErrors();
+      if (activeErrors2 instanceof Map) {
+        if (map.size === 0 && activeErrors2.size === 0) {
+          break L37;
+        }
+        const set = new Set(map.keys());
+        const set2 = new Set(activeErrors2.keys());
+        if (set.size > set2.size) {
+          for (const item3 of setDifference(set, set2)) {
+            const r114 = map.get(item3);
+            if (r114 != null) {
+              reportAVError(r114);
+            }
+          }
+        }
+        if (set2.size > set.size) {
+          for (const item4 of setDifference(set2, set)) {
+            const r137 = activeErrors2.get(item4);
+            if (r137 != null) {
+              c12006_9.info(`Error resolved: ${r137.type} ${JSON.stringify(_objectWithoutProperties(r137, _excluded))}`);
+            }
+          }
+        }
+        Dispatcher.dispatch({
+          type: "ACTIVE_AV_ERRORS_CHANGED",
+          activeErrors: map
+        });
+      } else {
+        c12006_9.error(`existingErrors is not a Map: ${activeErrors2} type: ${Object.prototype.toString.call(activeErrors2)}`);
+      }
+    }
+  }
+  handleReportAVError(a0) {
+    sendAVErrorAnalyticsEvent(a0.error, a0.context);
+  }
+}
+const aVErrorManager = new AVErrorManager();
+export default aVErrorManager;

modules/errors/av_errors/AVErrorStore.tsx

@@ -0,0 +1,65 @@
+// Metro module 10546 (f10547).
+import Module589 from "../../../_bundle/Module589";
+import { areSetsEqual } from "../../../_bundle/Module1414";
+import Dispatcher from "../../../Dispatcher";
+let activeErrors, c7087_4;
+const isAVErrorContextOfType = function isAVErrorContextOfType(a0, a1) {
+  return a0.type === a1;
+};
+activeErrors = new Map();
+c7087_4 = new Map();
+class AVErrorStore extends Module589.Store {
+  static displayName = "AVErrorStore";
+  hasActiveErrorOfType(a0) {
+    let r6 = c7087_4.get(a0);
+    if (r6 == null) {
+      r6 = [];
+    }
+    return r6.length > 0;
+  }
+  getActiveErrors() {
+    if (!(activeErrors instanceof Map)) {
+      activeErrors = new Map();
+    }
+    return activeErrors;
+  }
+  getActiveErrorsOfType(a0) {
+    const r0 = [];
+    const r24 = c7087_4.get(a0);
+    if (r24 == null) {
+      return r0;
+    }
+    for (const item of r24) {
+      const r30 = activeErrors.get(item);
+      if (r30 != null && isAVErrorContextOfType(r30, a0)) {
+        r0.push(r30);
+      }
+    }
+    return r0;
+  }
+}
+const aVErrorStore = new AVErrorStore(Dispatcher, {
+  ACTIVE_AV_ERRORS_CHANGED: function handleActiveErrorsChanged({ activeErrors: activeErrors2 }) {
+    if (!(activeErrors2 instanceof Map)) {
+      return false;
+    }
+    if (!(activeErrors instanceof Map)) {
+      activeErrors = new Map();
+    }
+    if (areSetsEqual(new Set(activeErrors2.keys()), new Set(activeErrors.keys()))) {
+      return false;
+    }
+    activeErrors = activeErrors2;
+    c7087_4 = new Map();
+    for (const item of activeErrors.entries()) {
+      const [r67, r68] = item;
+      let r73 = c7087_4.get(r68.type);
+      if (r73 == null) {
+        r73 = [];
+      }
+      r73.push(r67);
+      c7087_4.set(r68.type, r73);
+    }
+  }
+});
+export default aVErrorStore;

modules/errors/av_errors/AVErrorUtils.tsx

@@ -0,0 +1,19 @@
+// Metro module 16677 (f16678).
+import MediaEngineStatsStore from "../../media_engine/MediaEngineStatsStore";
+import Durations from "../../../utils/Durations";
+import { WindowVisibilityVideoManager } from "../../../lib/WindowVisibilityVideoManager";
+let c12011_3 = 10 * Durations.Millis.SECOND;
+export function getReportInboundErrors() {
+  return WindowVisibilityVideoManager.isIncomingVideoEnabled() && performance.now() - WindowVisibilityVideoManager.lastIncomingVideoEnabledChangeTime() > c12011_3;
+}
+export function getAccumulatedStatsWithMinDatapoints(a0, a1, r7 = 15) {
+  const accumulatedPerformanceStats = MediaEngineStatsStore.getAccumulatedPerformanceStats(a0, a1, "short");
+  const accumulatedPerformanceStats2 = MediaEngineStatsStore.getAccumulatedPerformanceStats(a0, a1, "long");
+  return accumulatedPerformanceStats == null ? null : accumulatedPerformanceStats2 == null ? null : accumulatedPerformanceStats.numDatapoints < r7 ? null : accumulatedPerformanceStats2.numDatapoints < r7 ? null : {
+    short: accumulatedPerformanceStats,
+    long: accumulatedPerformanceStats2
+  };
+}
+export function getWarningFrameRate(r5 = 30) {
+  return r5 <= 5 ? 3 : r5 <= 15 ? 8 : r5 <= 30 ? 15 : 30;
+}

modules/errors/av_errors/definitions/AVErrorAudioCaptureSampleRateMismatch.tsx

@@ -0,0 +1,32 @@
+// Metro module 16686 (f16687).
+import MediaEngineStatsStore from "../../../media_engine/MediaEngineStatsStore";
+import MediaEngineStore from "../../../../stores/MediaEngineStore";
+import RTCConnectionStore from "../../../../stores/RTCConnectionStore";
+import Durations from "../../../../utils/Durations";
+import { AVError } from "../AVError";
+import { getVoiceChannelErrorContext } from "../AVErrorContext";
+let c12020_5 = 10 * Durations.Millis.SECOND;
+const r25 = {
+  getActiveErrors: () => {
+    const rTCConnection = RTCConnectionStore.getRTCConnection();
+    let r14 = rTCConnection == null ? void 0 : rTCConnection.getDurationSeconds();
+    if (r14 == null) {
+      r14 = 0;
+    }
+    if (!(r14 < 30) && !(performance.now() - MediaEngineStore.getLastAudioInputDeviceChangeTimestamp() < c12020_5)) {
+      const rTCConnection2 = RTCConnectionStore.getRTCConnection();
+      const connectionStats = MediaEngineStatsStore.getConnectionStats(rTCConnection2 == null ? void 0 : rTCConnection2.getMediaEngineConnectionId());
+      let audioCaptureSampleRateMismatchPercent = connectionStats == null ? void 0 : connectionStats.stats.rtp.outbound.find((item) => item.type === "audio")?.sampleRateMismatchPercent;
+      if (audioCaptureSampleRateMismatchPercent == null) {
+        audioCaptureSampleRateMismatchPercent = 0;
+      }
+      return Math.abs(audioCaptureSampleRateMismatchPercent) > 30 ? [{
+        type: AVError.AUDIO_CAPTURE_SAMPLE_RATE_MISMATCH,
+        audioCaptureSampleRateMismatchPercent,
+        ...getVoiceChannelErrorContext()
+      }] : void 0;
+    }
+  },
+  makeErrorContextKey: (a0) => `${a0.mediaSessionId}:${a0.audioInputDeviceName}`
+};
+export { r25 as AVErrorAudioCaptureSampleRateMismatchDefinition };

modules/errors/av_errors/definitions/AVErrorCameraSendLowFPS.tsx

@@ -0,0 +1,43 @@
+// Metro module 16691 (f16692).
+import AuthenticationStore from "../../../../stores/AuthenticationStore";
+import MediaEngineStore from "../../../../stores/MediaEngineStore";
+import RTCConnectionStore from "../../../../stores/RTCConnectionStore";
+import Durations from "../../../../utils/Durations";
+import { getAccumulatedStatsWithMinDatapoints } from "../AVErrorUtils";
+import { AVError } from "../AVError";
+import { getVoiceChannelErrorContext } from "../AVErrorContext";
+let c12025_5 = 20 * Durations.Millis.SECOND;
+const r25 = {
+  getActiveErrors: () => {
+    const rTCConnection = RTCConnectionStore.getRTCConnection();
+    if (rTCConnection == null) {
+      return null;
+    }
+    const mediaEngineConnectionId = rTCConnection.getMediaEngineConnectionId();
+    if (mediaEngineConnectionId == null) {
+      return null;
+    }
+    if (MediaEngineStore.isVideoEnabled()) {
+      const lastNonZeroRemoteVideoSinkWantsTime = RTCConnectionStore.getLastNonZeroRemoteVideoSinkWantsTime();
+      if (lastNonZeroRemoteVideoSinkWantsTime != null && performance.now() - lastNonZeroRemoteVideoSinkWantsTime < c12025_5) {
+        return null;
+      }
+      if (rTCConnection.hasActiveRemoteWants()) {
+        const accumulatedStatsWithMinDatapoints = getAccumulatedStatsWithMinDatapoints(mediaEngineConnectionId, AuthenticationStore.getId());
+        return accumulatedStatsWithMinDatapoints == null ? null : accumulatedStatsWithMinDatapoints.short.frameRate < 10 ? [{
+          type: AVError.CAMERA_SEND_LOW_FPS,
+          userId: AuthenticationStore.getId(),
+          ...getVoiceChannelErrorContext()
+        }] : accumulatedStatsWithMinDatapoints.long.frameRate < 10 ? [{
+          type: AVError.CAMERA_SEND_LOW_FPS,
+          userId: AuthenticationStore.getId(),
+          ...getVoiceChannelErrorContext()
+        }] : void 0;
+      }
+      return null;
+    }
+    return null;
+  },
+  makeErrorContextKey: (a0) => `${a0.mediaSessionId}`
+};
+export { r25 as AVErrorCameraSendLowFPSDefinition };

modules/errors/av_errors/definitions/AVErrorNoAudioInputDetected.tsx

@@ -0,0 +1,22 @@
+// Metro module 16673 (f16674).
+import ChannelStore from "../../../../stores/ChannelStore";
+import MediaEngineStore from "../../../../stores/MediaEngineStore";
+import RTCConnectionStore from "../../../../stores/RTCConnectionStore";
+import { InputModes, RTCConnectionStates } from "../../../../Constants";
+import { AVError } from "../AVError";
+import { getVoiceChannelErrorContext } from "../AVErrorContext";
+const r23 = {
+  getActiveErrors: ({ voiceChannelId, voiceState }) => {
+    const channel = ChannelStore.getChannel(voiceChannelId);
+    const r12 = (channel == null ? void 0 : channel.isGuildStageVoice()) && voiceState?.suppress;
+    const mediaSessionId = RTCConnectionStore.getMediaSessionId();
+    if (channel != null && mediaSessionId != null && !MediaEngineStore.getInputDetectedThisConnection() && RTCConnectionStore.getState() === RTCConnectionStates.RTC_CONNECTED && MediaEngineStore.getSettings().mode === InputModes.VOICE_ACTIVITY && MediaEngineStore.getSettings().silenceWarning && MediaEngineStore.getInputDetected() === false && !r12 && !MediaEngineStore.isSelfMute()) {
+      return [{
+        type: AVError.NO_AUDIO_INPUT_DETECTED,
+        ...getVoiceChannelErrorContext()
+      }];
+    }
+  },
+  makeErrorContextKey: (a0) => `${a0.mediaSessionId}:${a0.audioInputDeviceName}`
+};
+export { r23 as AVErrorNoAudioInputDetectedDefinition };

modules/errors/av_errors/definitions/AVErrorNoInputDevices.tsx

@@ -0,0 +1,22 @@
+// Metro module 16675 (f16676).
+import ChannelStore from "../../../../stores/ChannelStore";
+import MediaEngineStore from "../../../../stores/MediaEngineStore";
+import RTCConnectionStore from "../../../../stores/RTCConnectionStore";
+import { AVError } from "../AVError";
+import { getVoiceChannelErrorContext } from "../AVErrorContext";
+const r19 = {
+  getActiveErrors: ({ voiceChannelId, voiceState }) => {
+    const channel = ChannelStore.getChannel(voiceChannelId);
+    const r15 = (channel == null ? void 0 : channel.isGuildStageVoice()) && voiceState?.suppress;
+    const length = Object.keys(MediaEngineStore.getInputDevices()).length;
+    const mediaSessionId = RTCConnectionStore.getMediaSessionId();
+    if (length === 0 && channel != null && mediaSessionId != null && !r15) {
+      return [{
+        type: AVError.NO_INPUT_DEVICES,
+        ...getVoiceChannelErrorContext()
+      }];
+    }
+  },
+  makeErrorContextKey: (a0) => `${a0.mediaSessionId}`
+};
+export { r19 as AVErrorNoInputDevicesDefinition };

modules/errors/av_errors/definitions/AVErrorScreenshareOSError.tsx

@@ -0,0 +1,18 @@
+// Metro module 16685 (f16686).
+import { isMac } from "../../../../utils/PlatformUtils";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+import { encodeStreamKey } from "../../../go_live/utils/StreamKeyUtils";
+let c12019_2 = BigInt(-3821);
+const r15 = {
+  getActiveErrors: (a0) => a0.activeStreams.filter((activeStream) => activeStream.errorCode != null).map((item) => {
+    const errorCode = item.errorCode;
+    return {
+      type: AVError.SCREENSHARE_OS_ERROR,
+      errorMessage: isMac() && errorCode === c12019_2 ? `${errorCode} - your Mac may be low on disk space` : errorCode.toString(),
+      ...getStreamErrorContext(encodeStreamKey(item))
+    };
+  }),
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r15 as AVErrorScreenshareOSErrorDefinition };

modules/errors/av_errors/definitions/AVErrorStreamBadNetworkQuality.tsx

@@ -0,0 +1,14 @@
+// Metro module 16681 (f16682).
+import StreamRTCConnectionStore from "../../../../stores/StreamRTCConnectionStore";
+import { RTCConnectionQuality } from "../../../../Constants";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+import { isNotNullish } from "../../../../utils/GlobalUtils";
+const r18 = {
+  getActiveErrors: () => StreamRTCConnectionStore.getAllActiveStreamKeys().map((item) => StreamRTCConnectionStore.getQuality(item) === RTCConnectionQuality.BAD ? {
+    type: AVError.STREAM_BAD_NETWORK_QUALITY,
+    ...getStreamErrorContext(item)
+  } : null).filter(isNotNullish),
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r18 as AVErrorStreamBadNetworkQualityDefinition };

modules/errors/av_errors/definitions/AVErrorStreamFailedToStart.tsx

@@ -0,0 +1,13 @@
+// Metro module 16683 (f16684).
+import { ApplicationStreamStates } from "../../../../Constants";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+import { encodeStreamKey } from "../../../go_live/utils/StreamKeyUtils";
+const r15 = {
+  getActiveErrors: (a0) => a0.activeStreams.filter((activeStream) => activeStream.state === ApplicationStreamStates.FAILED && activeStream.errorCode == null).map((item) => ({
+    type: AVError.STREAM_FAILED_TO_START,
+    ...getStreamErrorContext(encodeStreamKey(item))
+  })),
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r15 as AVErrorStreamFailedToStartDefinition };

modules/errors/av_errors/definitions/AVErrorStreamReconnecting.tsx

@@ -0,0 +1,13 @@
+// Metro module 16684 (f16685).
+import { ApplicationStreamStates } from "../../../../Constants";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+import { encodeStreamKey } from "../../../go_live/utils/StreamKeyUtils";
+const r15 = {
+  getActiveErrors: (a0) => a0.activeStreams.filter((activeStream) => activeStream.state === ApplicationStreamStates.RECONNECTING).map((item) => ({
+    type: AVError.STREAM_RECONNECTING,
+    ...getStreamErrorContext(encodeStreamKey(item))
+  })),
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r15 as AVErrorStreamReconnectingDefinition };

modules/errors/av_errors/definitions/AVErrorStreamSendHighPacketLoss.tsx

@@ -0,0 +1,33 @@
+// Metro module 16679 (f16680).
+import ApplicationStreamingStore from "../../../../stores/ApplicationStreamingStore";
+import StreamRTCConnectionStore from "../../../../stores/StreamRTCConnectionStore";
+import { encodeStreamKey } from "../../../go_live/utils/StreamKeyUtils";
+import { getAccumulatedStatsWithMinDatapoints } from "../AVErrorUtils";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+const r17 = {
+  getActiveErrors: () => {
+    const currentUserActiveStream = ApplicationStreamingStore.getCurrentUserActiveStream();
+    if (currentUserActiveStream == null) {
+      return null;
+    }
+    if (ApplicationStreamingStore.getViewerIds(currentUserActiveStream).length === 0) {
+      return null;
+    }
+    const rTCConnection = StreamRTCConnectionStore.getRTCConnection(encodeStreamKey(currentUserActiveStream));
+    const r25 = rTCConnection == null ? void 0 : rTCConnection.getMediaEngineConnectionId();
+    if (r25 == null) {
+      return null;
+    }
+    const accumulatedStatsWithMinDatapoints = getAccumulatedStatsWithMinDatapoints(r25, currentUserActiveStream.ownerId);
+    return accumulatedStatsWithMinDatapoints == null ? null : 10 < 100 * accumulatedStatsWithMinDatapoints.short.packetLossRate ? [{
+      type: AVError.STREAM_SEND_HIGH_PACKET_LOSS,
+      ...getStreamErrorContext(encodeStreamKey(currentUserActiveStream))
+    }] : 10 < 100 * accumulatedStatsWithMinDatapoints.long.packetLossRate ? [{
+      type: AVError.STREAM_SEND_HIGH_PACKET_LOSS,
+      ...getStreamErrorContext(encodeStreamKey(currentUserActiveStream))
+    }] : void 0;
+  },
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r17 as AVErrorStreamSendHighPacketLossDefinition };

modules/errors/av_errors/definitions/AVErrorStreamSendLowFPS.tsx

@@ -0,0 +1,57 @@
+// Metro module 16680 (f16681).
+import ChannelRTCStore from "../../../calls/ChannelRTCStore";
+import ApplicationStreamingStore from "../../../../stores/ApplicationStreamingStore";
+import StreamRTCConnectionStore from "../../../../stores/StreamRTCConnectionStore";
+import { ApplicationStreamStates } from "../../../../Constants";
+import Durations from "../../../../utils/Durations";
+import { encodeStreamKey } from "../../../go_live/utils/StreamKeyUtils";
+import { getAccumulatedStatsWithMinDatapoints, getWarningFrameRate } from "../AVErrorUtils";
+import { getMaxQuality } from "../../../../utils/StreamQualityUtils";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+let c12014_6 = 20 * Durations.Millis.SECOND;
+const r28 = {
+  getActiveErrors: () => {
+    const currentUserActiveStream = ApplicationStreamingStore.getCurrentUserActiveStream();
+    if (currentUserActiveStream != null && currentUserActiveStream.state !== ApplicationStreamStates.PAUSED) {
+      if (ApplicationStreamingStore.getViewerIds(currentUserActiveStream).length === 0) {
+        return null;
+      }
+      const r12 = encodeStreamKey(currentUserActiveStream);
+      const rTCConnection = StreamRTCConnectionStore.getRTCConnection(r12);
+      if (rTCConnection == null) {
+        return null;
+      }
+      const mediaEngineConnectionId = rTCConnection.getMediaEngineConnectionId();
+      if (mediaEngineConnectionId == null) {
+        return null;
+      }
+      const lastNonZeroRemoteVideoSinkWantsTime = StreamRTCConnectionStore.getLastNonZeroRemoteVideoSinkWantsTime(r12);
+      if (lastNonZeroRemoteVideoSinkWantsTime != null && performance.now() - lastNonZeroRemoteVideoSinkWantsTime < c12014_6) {
+        return null;
+      }
+      if (rTCConnection.hasActiveRemoteWants()) {
+        const participant = ChannelRTCStore.getParticipant(currentUserActiveStream.channelId, encodeStreamKey(currentUserActiveStream));
+        if (participant == null) {
+          return null;
+        }
+        const accumulatedStatsWithMinDatapoints = getAccumulatedStatsWithMinDatapoints(mediaEngineConnectionId, currentUserActiveStream.ownerId);
+        if (accumulatedStatsWithMinDatapoints == null) {
+          return null;
+        }
+        const maxQuality = getMaxQuality(participant);
+        return maxQuality == null ? null : accumulatedStatsWithMinDatapoints.short.frameRate < getWarningFrameRate(maxQuality.maxFrameRate) ? [{
+          type: AVError.STREAM_SEND_LOW_FPS,
+          ...getStreamErrorContext(encodeStreamKey(currentUserActiveStream))
+        }] : accumulatedStatsWithMinDatapoints.long.frameRate < getWarningFrameRate(maxQuality.maxFrameRate) ? [{
+          type: AVError.STREAM_SEND_LOW_FPS,
+          ...getStreamErrorContext(encodeStreamKey(currentUserActiveStream))
+        }] : null;
+      }
+      return null;
+    }
+    return null;
+  },
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r28 as AVErrorStreamSendLowFPSDefinition };

modules/errors/av_errors/definitions/AVErrorStreamSoundshareFailed.tsx

@@ -0,0 +1,18 @@
+// Metro module 16682 (f16683).
+import ApplicationStreamingStore from "../../../../stores/ApplicationStreamingStore";
+import HookErrorStore from "../../../../stores/HookErrorStore";
+import { MediaEngineHookTypes } from "../../../../Constants";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+import { encodeStreamKey } from "../../../go_live/utils/StreamKeyUtils";
+const r20 = {
+  getActiveErrors: () => {
+    const currentUserActiveStream = ApplicationStreamingStore.getCurrentUserActiveStream();
+    return currentUserActiveStream != null ? HookErrorStore.getHookError(MediaEngineHookTypes.SOUND) != null ? [{
+      type: AVError.STREAM_SOUNDSHARE_FAILED,
+      ...getStreamErrorContext(encodeStreamKey(currentUserActiveStream))
+    }] : void 0 : void 0;
+  },
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r20 as AVErrorStreamSoundshareFailedDefinition };

modules/errors/av_errors/definitions/AVErrorStreamViewHighPacketLoss.tsx

@@ -0,0 +1,35 @@
+// Metro module 16678 (f16679).
+import ApplicationStreamingStore from "../../../../stores/ApplicationStreamingStore";
+import AuthenticationStore from "../../../../stores/AuthenticationStore";
+import StreamRTCConnectionStore from "../../../../stores/StreamRTCConnectionStore";
+import { getReportInboundErrors, getAccumulatedStatsWithMinDatapoints } from "../AVErrorUtils";
+import { encodeStreamKey } from "../../../go_live/utils/StreamKeyUtils";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+const r19 = {
+  getActiveErrors: () => getReportInboundErrors() ? ApplicationStreamingStore.getAllActiveStreams().reduce((acc, item) => {
+    const rTCConnection = StreamRTCConnectionStore.getRTCConnection(encodeStreamKey(item));
+    const r19 = rTCConnection == null ? void 0 : rTCConnection.getMediaEngineConnectionId();
+    if (r19 == null) {
+      return acc;
+    }
+    if (item.ownerId === AuthenticationStore.getId()) {
+      return acc;
+    }
+    L8: {
+      const accumulatedStatsWithMinDatapoints = getAccumulatedStatsWithMinDatapoints(r19, item.ownerId);
+      if (accumulatedStatsWithMinDatapoints != null) {
+        if (!(10 < 100 * accumulatedStatsWithMinDatapoints.short.packetLossRate) && !(10 < 100 * accumulatedStatsWithMinDatapoints.long.packetLossRate)) {
+          break L8;
+        }
+        acc.push.call(acc, {
+          type: AVError.STREAM_VIEW_HIGH_PACKET_LOSS,
+          ...getStreamErrorContext(encodeStreamKey(item))
+        });
+      }
+    }
+    return acc;
+  }, []) : null,
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r19 as AVErrorStreamViewHighPacketLossDefinition };

modules/errors/av_errors/definitions/AVErrorStreamViewLowFPS.tsx

@@ -0,0 +1,46 @@
+// Metro module 16676 (f16677).
+import ChannelRTCStore from "../../../calls/ChannelRTCStore";
+import ApplicationStreamingStore from "../../../../stores/ApplicationStreamingStore";
+import AuthenticationStore from "../../../../stores/AuthenticationStore";
+import StreamRTCConnectionStore from "../../../../stores/StreamRTCConnectionStore";
+import { ApplicationStreamStates } from "../../../../Constants";
+import { getReportInboundErrors, getAccumulatedStatsWithMinDatapoints, getWarningFrameRate } from "../AVErrorUtils";
+import { encodeStreamKey } from "../../../go_live/utils/StreamKeyUtils";
+import { getMaxQuality } from "../../../../utils/StreamQualityUtils";
+import { AVError } from "../AVError";
+import { getStreamErrorContext } from "../AVErrorContext";
+const r24 = {
+  getActiveErrors: () => getReportInboundErrors() ? ApplicationStreamingStore.getAllActiveStreams().reduce((acc, item) => {
+    const rTCConnection = StreamRTCConnectionStore.getRTCConnection(encodeStreamKey(item));
+    const r11 = rTCConnection == null ? void 0 : rTCConnection.getMediaEngineConnectionId();
+    if (r11 == null) {
+      return acc;
+    }
+    if (item.ownerId !== AuthenticationStore.getId() && item.state !== ApplicationStreamStates.PAUSED) {
+      const accumulatedStatsWithMinDatapoints = getAccumulatedStatsWithMinDatapoints(r11, item.ownerId);
+      if (accumulatedStatsWithMinDatapoints == null) {
+        return acc;
+      }
+      const participant = ChannelRTCStore.getParticipant(item.channelId, encodeStreamKey(item));
+      if (participant == null) {
+        return acc;
+      }
+      L11: {
+        const maxQuality = getMaxQuality(participant);
+        if (maxQuality != null) {
+          if (!(accumulatedStatsWithMinDatapoints.short.frameRate < getWarningFrameRate(maxQuality.maxFrameRate)) && !(accumulatedStatsWithMinDatapoints.long.frameRate < getWarningFrameRate(maxQuality.maxFrameRate))) {
+            break L11;
+          }
+          acc.push.call(acc, {
+            type: AVError.STREAM_VIEW_LOW_FPS,
+            ...getStreamErrorContext(encodeStreamKey(item))
+          });
+        }
+      }
+      return acc;
+    }
+    return acc;
+  }, []) : null,
+  makeErrorContextKey: (a0) => `${a0.streamKey}:${a0.mediaSessionId}`
+};
+export { r24 as AVErrorStreamViewLowFPSDefinition };

modules/errors/av_errors/definitions/AVErrorVideoStreamReceiverReadyTimeout.tsx

@@ -0,0 +1,12 @@
+// Metro module 16688 (f16689).
+import AuthenticationStore from "../../../../stores/AuthenticationStore";
+import VideoStreamStore from "../../../../stores/VideoStreamStore";
+import { AVError } from "../AVError";
+const r17 = {
+  getActiveErrors: () => Object.values(VideoStreamStore.getTimedoutVideos()).filter(({ userId, videoStreamId }) => AuthenticationStore.getId() !== userId && videoStreamId != null).map((item) => ({
+    type: AVError.VIDEO_STREAM_RECEIVER_READY_TIMEOUT,
+    ...item
+  })),
+  makeErrorContextKey: (a0) => `${a0.mediaContext}:${a0.userId}`
+};
+export { r17 as AVErrorVideoStreamReceiverReadyTimeoutDefinition };

modules/errors/av_errors/definitions/AVErrorVideoStreamReceiverReadyTimeoutNoStream.tsx

@@ -0,0 +1,12 @@
+// Metro module 16690 (f16691).
+import AuthenticationStore from "../../../../stores/AuthenticationStore";
+import VideoStreamStore from "../../../../stores/VideoStreamStore";
+import { AVError } from "../AVError";
+const r17 = {
+  getActiveErrors: () => Object.values(VideoStreamStore.getTimedoutVideos()).filter(({ userId, videoStreamId }) => AuthenticationStore.getId() !== userId && videoStreamId == null).map((item) => ({
+    type: AVError.VIDEO_STREAM_RECEIVER_READY_TIMEOUT_NO_STREAM,
+    ...item
+  })),
+  makeErrorContextKey: (a0) => `${a0.mediaContext}:${a0.userId}`
+};
+export { r17 as AVErrorVideoStreamReceiverReadyTimeoutNoStreamDefinition };

modules/errors/av_errors/definitions/AVErrorVideoStreamSenderReadyTimeout.tsx

@@ -0,0 +1,12 @@
+// Metro module 16687 (f16688).
+import AuthenticationStore from "../../../../stores/AuthenticationStore";
+import VideoStreamStore from "../../../../stores/VideoStreamStore";
+import { AVError } from "../AVError";
+const r17 = {
+  getActiveErrors: () => Object.values(VideoStreamStore.getTimedoutVideos()).filter(({ userId, videoStreamId }) => AuthenticationStore.getId() === userId && videoStreamId != null).map((item) => ({
+    type: AVError.VIDEO_STREAM_SENDER_READY_TIMEOUT,
+    ...item
+  })),
+  makeErrorContextKey: (a0) => `${a0.mediaContext}:${a0.userId}`
+};
+export { r17 as AVErrorVideoStreamSenderReadyTimeoutDefinition };

modules/errors/av_errors/definitions/AVErrorVideoStreamSenderReadyTimeoutNoStream.tsx

@@ -0,0 +1,12 @@
+// Metro module 16689 (f16690).
+import AuthenticationStore from "../../../../stores/AuthenticationStore";
+import VideoStreamStore from "../../../../stores/VideoStreamStore";
+import { AVError } from "../AVError";
+const r17 = {
+  getActiveErrors: () => Object.values(VideoStreamStore.getTimedoutVideos()).filter(({ userId, videoStreamId }) => AuthenticationStore.getId() === userId && videoStreamId == null).map((item) => ({
+    type: AVError.VIDEO_STREAM_SENDER_READY_TIMEOUT_NO_STREAM,
+    ...item
+  })),
+  makeErrorContextKey: (a0) => `${a0.mediaContext}:${a0.userId}`
+};
+export { r17 as AVErrorVideoStreamSenderReadyTimeoutNoStreamDefinition };

modules/errors/av_errors/definitions/index.tsx

@@ -0,0 +1,38 @@
+// Metro module 16672 (f16673).
+import { AVError } from "../AVError";
+import { AVErrorNoAudioInputDetectedDefinition } from "./AVErrorNoAudioInputDetected";
+import { AVErrorNoInputDevicesDefinition } from "./AVErrorNoInputDevices";
+import { AVErrorStreamViewLowFPSDefinition } from "./AVErrorStreamViewLowFPS";
+import { AVErrorStreamViewHighPacketLossDefinition } from "./AVErrorStreamViewHighPacketLoss";
+import { AVErrorStreamSendHighPacketLossDefinition } from "./AVErrorStreamSendHighPacketLoss";
+import { AVErrorStreamSendLowFPSDefinition } from "./AVErrorStreamSendLowFPS";
+import { AVErrorStreamBadNetworkQualityDefinition } from "./AVErrorStreamBadNetworkQuality";
+import { AVErrorStreamSoundshareFailedDefinition } from "./AVErrorStreamSoundshareFailed";
+import { AVErrorStreamFailedToStartDefinition } from "./AVErrorStreamFailedToStart";
+import { AVErrorStreamReconnectingDefinition } from "./AVErrorStreamReconnecting";
+import { AVErrorScreenshareOSErrorDefinition } from "./AVErrorScreenshareOSError";
+import { AVErrorAudioCaptureSampleRateMismatchDefinition } from "./AVErrorAudioCaptureSampleRateMismatch";
+import { AVErrorVideoStreamSenderReadyTimeoutDefinition } from "./AVErrorVideoStreamSenderReadyTimeout";
+import { AVErrorVideoStreamReceiverReadyTimeoutDefinition } from "./AVErrorVideoStreamReceiverReadyTimeout";
+import { AVErrorVideoStreamSenderReadyTimeoutNoStreamDefinition } from "./AVErrorVideoStreamSenderReadyTimeoutNoStream";
+import { AVErrorVideoStreamReceiverReadyTimeoutNoStreamDefinition } from "./AVErrorVideoStreamReceiverReadyTimeoutNoStream";
+import { AVErrorCameraSendLowFPSDefinition } from "./AVErrorCameraSendLowFPS";
+const r10 = {};
+r10[AVError.NO_AUDIO_INPUT_DETECTED] = AVErrorNoAudioInputDetectedDefinition;
+r10[AVError.NO_INPUT_DEVICES] = AVErrorNoInputDevicesDefinition;
+r10[AVError.STREAM_VIEW_LOW_FPS] = AVErrorStreamViewLowFPSDefinition;
+r10[AVError.STREAM_VIEW_HIGH_PACKET_LOSS] = AVErrorStreamViewHighPacketLossDefinition;
+r10[AVError.STREAM_SEND_HIGH_PACKET_LOSS] = AVErrorStreamSendHighPacketLossDefinition;
+r10[AVError.STREAM_SEND_LOW_FPS] = AVErrorStreamSendLowFPSDefinition;
+r10[AVError.STREAM_BAD_NETWORK_QUALITY] = AVErrorStreamBadNetworkQualityDefinition;
+r10[AVError.STREAM_SOUNDSHARE_FAILED] = AVErrorStreamSoundshareFailedDefinition;
+r10[AVError.STREAM_FAILED_TO_START] = AVErrorStreamFailedToStartDefinition;
+r10[AVError.STREAM_RECONNECTING] = AVErrorStreamReconnectingDefinition;
+r10[AVError.SCREENSHARE_OS_ERROR] = AVErrorScreenshareOSErrorDefinition;
+r10[AVError.AUDIO_CAPTURE_SAMPLE_RATE_MISMATCH] = AVErrorAudioCaptureSampleRateMismatchDefinition;
+r10[AVError.VIDEO_STREAM_SENDER_READY_TIMEOUT] = AVErrorVideoStreamSenderReadyTimeoutDefinition;
+r10[AVError.VIDEO_STREAM_RECEIVER_READY_TIMEOUT] = AVErrorVideoStreamReceiverReadyTimeoutDefinition;
+r10[AVError.VIDEO_STREAM_SENDER_READY_TIMEOUT_NO_STREAM] = AVErrorVideoStreamSenderReadyTimeoutNoStreamDefinition;
+r10[AVError.VIDEO_STREAM_RECEIVER_READY_TIMEOUT_NO_STREAM] = AVErrorVideoStreamReceiverReadyTimeoutNoStreamDefinition;
+r10[AVError.CAMERA_SEND_LOW_FPS] = AVErrorCameraSendLowFPSDefinition;
+export { r10 as ErrorDefinitions };