app.hypergames.hypersdk 1.8.1 → 1.8.3

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [1.8.3](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.2...v1.8.3) (2026-04-10)
+
+
+### Bug Fixes
+
+* WebGL reliability, scores, connection UI, and session-end audio ([adda0d9](https://github.com/mvmhyper/hyper-sdk/commit/adda0d9a688e786872c82a6429ce31b160e6b5e3))
+
+## [1.8.2](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.1...v1.8.2) (2026-04-07)
+
+
+### Bug Fixes
+
+* **ui:** adjust canvas scaler match value for landscape to 0.63 ([c8e98ba](https://github.com/mvmhyper/hyper-sdk/commit/c8e98ba2fd112f5501959a3e7dc078fe4dc4cba3))
+
 ## [1.8.1](https://github.com/mvmhyper/hyper-sdk/compare/v1.8.0...v1.8.1) (2026-04-02)
 
 

package/HyperLoader.unity

@@ -305,7 +305,7 @@ RectTransform:
   m_AnchorMin: {x: 0, y: 1}
   m_AnchorMax: {x: 0, y: 1}
   m_AnchoredPosition: {x: 489.45853, y: -280.1698}
-  m_SizeDelta: {x: 1044.9, y: 239.347}
+  m_SizeDelta: {x: 0, y: 239.347}
   m_Pivot: {x: 0.5, y: 0.5}
 --- !u!114 &751153944
 MonoBehaviour:
@@ -840,7 +840,7 @@ GameObject:
   m_Component:
   - component: {fileID: 1064166296}
   m_Layer: 0
-  m_Name: __HyperSDK_BuildMarker_639104165398939431
+  m_Name: __HyperSDK_BuildMarker_639114595732632449
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0

package/Runtime/Internal/Data/URLData.cs

@@ -57,57 +57,53 @@ namespace Hyper.Internal
 
         public string WorkspaceId
         {
-            get => string.IsNullOrEmpty(_workspaceId) ? (_workspaceId = Guid.NewGuid().ToString()) : _workspaceId;
-            set => _workspaceId = value;
+            get => _workspaceId;
+            set => _workspaceId = string.Copy(value);
         }
 
         public string TournamentId
         {
             get
             {
-                if (string.IsNullOrEmpty(OldTournamentId) && string.IsNullOrEmpty(_tournamentId))
-                {
-                    _tournamentId = Guid.NewGuid().ToString();
-                }
                 return string.IsNullOrEmpty(OldTournamentId) ? _tournamentId : OldTournamentId;
             }
-            set => _tournamentId = value;
+            set => _tournamentId = string.Copy(value);
         }
 
         public string SessionId
         {
-            get => string.IsNullOrEmpty(_sessionId) ? (_sessionId = Guid.NewGuid().ToString()) : _sessionId;
+            get => _sessionId;
             set => _sessionId = string.Copy(value);
         }
 
         public string GameId
         {
-            get => string.IsNullOrEmpty(_gameId) ? (_gameId = Guid.NewGuid().ToString()) : _gameId;
-            set => _gameId = value;
+            get => _gameId;
+            set => _gameId = string.Copy(value);
         }
 
         public string GameSlug
         {
             get => _gameSlug;
-            set => _gameSlug = value;
+            set => _gameSlug = string.Copy(value);
         }
 
         public string EntryId
         {
-            get => string.IsNullOrEmpty(_entryId) ? (_entryId = Guid.NewGuid().ToString()) : _entryId;
-            set => _entryId = value;
+            get => _entryId;
+            set => _entryId = string.Copy(value);
         }
 
         public string UserId
         {
-            get => string.IsNullOrEmpty(_userId) ? (_userId = Guid.NewGuid().ToString()) : _userId;
-            set => _userId = value;
+            get => _userId;
+            set => _userId = string.Copy(value);
         }
 
         public string EmbedUrl
         {
-            get => string.IsNullOrEmpty(_embedUrl) ? (_embedUrl = Guid.NewGuid().ToString()) : _embedUrl;
-            set => _embedUrl = value;
+            get => _embedUrl;
+            set => _embedUrl = string.Copy(value);
         }
 
         #endregion
@@ -116,7 +112,7 @@ namespace Hyper.Internal
         {
             GameMode = GameMode.Battle;
         }
-        
+
         public void SetModeAsPractice()
         {
             GameMode = GameMode.Practice;

package/Runtime/Internal/Managers/BackendManager.cs

@@ -1,4 +1,5 @@
 using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
 using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -64,6 +65,11 @@ namespace Hyper.Internal.Managers
 
         public SubmissionErrorType LastSubmissionError { get; private set; } = SubmissionErrorType.None;
 
+        /// <summary>
+        /// Smoothed round-trip latency (ms) from sdkPing/sdkPong, or -1 when unknown or disconnected.
+        /// </summary>
+        public int SdkSmoothedLatencyMs { get; private set; } = -1;
+
         #endregion
 
         #region Private Configuration
@@ -75,7 +81,7 @@ namespace Hyper.Internal.Managers
         /// Only uses production URL for release builds made via Build Assistant (HYPER_RELEASE_BUILD define).
         /// All other builds (development, editor, etc.) use the dev server URL.
         /// </summary>
-        private string GetServerUrl()
+        public string GetServerUrl()
         {
 #if HYPER_RELEASE_BUILD
             // Only release builds from Build Assistant use production URL
@@ -100,7 +106,7 @@ namespace Hyper.Internal.Managers
         private static extern string EncryptScore(string score);
 
         [DllImport("__Internal")]
-        private static extern void FetchAndCacheTutorials(string gameSlug, string gameObject);
+        private static extern void FetchAndCacheTutorials(string serverBaseUrl, string gameSlug, string gameObject);
 
         [DllImport("__Internal")]
         private static extern void InitWebSocket(string serverUrl);
@@ -116,7 +122,7 @@ namespace Hyper.Internal.Managers
 #else
         private string EncryptScore(string score) => score;
 
-        private void FetchAndCacheTutorials(string gameSlug, string gameObject)
+        private void FetchAndCacheTutorials(string serverBaseUrl, string gameSlug, string gameObject)
         {
             _isFetchingTutorial = false;
             _onTutorialSuccess?.Invoke();
@@ -239,6 +245,7 @@ namespace Hyper.Internal.Managers
                         _gameManager.Config.RandomSeed = randomSeed;
                         _gameManager.Config.SessionId = id;
                         _cachedSessionId = string.Copy(id);
+                        StartSdkPingLoop();
 
                         return true;
                     }
@@ -290,6 +297,14 @@ namespace Hyper.Internal.Managers
         private bool _isManuallyClosed;
         private bool _isSocketErrorCalled;
 
+        private Coroutine _sdkPingCoroutine;
+        private long _nextSdkPingId;
+        private long? _pendingSdkPingId;
+        private float _pendingSdkPingRealtime;
+        private float _sdkPingLatencyEma = -1f;
+        private const float SdkPingLatencyEmaAlpha = 0.25f;
+        private const float SdkPingIntervalSeconds = 3f;
+
         public void InitializeWebSocket()
         {
             if (_dataManager == null) _dataManager = HyperRuntime.DataManager;
@@ -313,9 +328,11 @@ namespace Hyper.Internal.Managers
 
         public void StopWebSocket()
         {
+            StopSdkPingLoop();
             _isManuallyClosed = true;
             isSocketConnected = false;
             CloseWebSocket();
+            _eventManager?.InvokeBackendSocketManuallyClosedEvent();
         }
 
         private IEnumerator StartWebSocketInitialization()
@@ -476,6 +493,73 @@ namespace Hyper.Internal.Managers
             _sendGameStartedCoroutine = null;
         }
 
+        private void StopSdkPingLoop()
+        {
+            if (_sdkPingCoroutine != null)
+            {
+                StopCoroutine(_sdkPingCoroutine);
+                _sdkPingCoroutine = null;
+            }
+
+            _pendingSdkPingId = null;
+            _sdkPingLatencyEma = -1f;
+            SdkSmoothedLatencyMs = -1;
+        }
+
+        private void StartSdkPingLoop()
+        {
+#if UNITY_WEBGL && !UNITY_EDITOR
+            if (_sdkPingCoroutine != null)
+                return;
+
+            _sdkPingCoroutine = StartCoroutine(SdkPingLoopCoroutine());
+#endif
+        }
+
+#if UNITY_WEBGL && !UNITY_EDITOR
+        private IEnumerator SdkPingLoopCoroutine()
+        {
+            while (true)
+            {
+                yield return new WaitForSecondsRealtime(SdkPingIntervalSeconds);
+                TrySendSdkPing();
+            }
+        }
+
+        private void TrySendSdkPing()
+        {
+            if (!isSocketConnected || string.IsNullOrEmpty(_cachedSessionId))
+                return;
+
+            if (_pendingSdkPingId.HasValue)
+                return;
+
+            long pingId = ++_nextSdkPingId;
+            _pendingSdkPingId = pingId;
+            _pendingSdkPingRealtime = Time.realtimeSinceStartup;
+
+            try
+            {
+                var message = new
+                {
+                    @event = "sdkPing",
+                    data = new
+                    {
+                        sessionId = _cachedSessionId,
+                        pingId
+                    }
+                };
+
+                string json = JsonConvert.SerializeObject(message);
+                SendWebSocketMessage(json);
+            }
+            catch (Exception ex)
+            {
+                _pendingSdkPingId = null;
+                HyperDebug.LogError($"[sdkPing] Send failed: {ex.Message}");
+            }
+        }
+#endif
 
         #endregion
 
@@ -508,10 +592,16 @@ namespace Hyper.Internal.Managers
             {
                 _eventManager?.InvokeConnectionFoundEvent();
             }
+
+            if (!string.IsNullOrEmpty(_cachedSessionId))
+            {
+                StartSdkPingLoop();
+            }
         }
 
         public void OnSocketDisconnected()
         {
+            StopSdkPingLoop();
             isSocketConnected = false;
 
             if (!_isManuallyClosed)
@@ -537,6 +627,7 @@ namespace Hyper.Internal.Managers
             }
 
             isSocketConnected = false;
+            StopSdkPingLoop();
         }
 
         public void OnSocketGameStarted(string message)
@@ -567,6 +658,38 @@ namespace Hyper.Internal.Managers
             // Reserved for future use
         }
 
+        public void OnSocketSdkPong(string message)
+        {
+            if (string.IsNullOrEmpty(message) || !_pendingSdkPingId.HasValue)
+                return;
+
+            try
+            {
+                JObject jo = JObject.Parse(message);
+                JToken token = jo["pingId"];
+                if (token == null || token.Type == JTokenType.Null)
+                    return;
+
+                long pongId = token.Value<long>();
+                if (pongId != _pendingSdkPingId.Value)
+                    return;
+
+                float rttMs = (Time.realtimeSinceStartup - _pendingSdkPingRealtime) * 1000f;
+                _pendingSdkPingId = null;
+
+                if (_sdkPingLatencyEma < 0f)
+                    _sdkPingLatencyEma = rttMs;
+                else
+                    _sdkPingLatencyEma = Mathf.Lerp(_sdkPingLatencyEma, rttMs, SdkPingLatencyEmaAlpha);
+
+                SdkSmoothedLatencyMs = Mathf.RoundToInt(_sdkPingLatencyEma);
+            }
+            catch (Exception ex)
+            {
+                HyperDebug.LogWarning($"[sdkPong] Failed to parse or apply: {ex.Message}");
+            }
+        }
+
         public void OnSocketScoreUpdated(string message)
         {
             if (_lastSentBatch != null && _lastSentBatch.Count > 0)
@@ -585,6 +708,12 @@ namespace Hyper.Internal.Managers
             }
 
             TryUpdateCSRFToken(message, "scoreUpdated");
+            if (!string.IsNullOrEmpty(_csrfToken))
+            {
+                _isWaitingForTokenLogEmitted = false;
+                int pendingCount = _dataManager?.PendingScores?.Count ?? 0;
+                HyperDebug.Log($"[CSRF] Fresh token received from scoreUpdated. Score sending can continue. PendingCount={pendingCount}");
+            }
         }
 
         private void TryUpdateCSRFToken(string json, string context = null)
@@ -849,6 +978,40 @@ namespace Hyper.Internal.Managers
                     yield return new WaitForSecondsRealtime(1f);
                 }
 
+                // Token-gated flow invalidates token after each send.
+                // Refresh token again before sending the final score payload.
+                if (string.IsNullOrEmpty(_csrfToken))
+                {
+                    _gameResumed = false;
+                    HyperDebug.Log("[CSRF] Token unavailable after backlog flush. Refreshing token before final score submit.");
+
+                    if (_sendGameResumedCoroutine == null)
+                    {
+                        _sendGameResumedCoroutine = StartCoroutine(SendGameResumedCoroutine());
+                        yield return _sendGameResumedCoroutine;
+                        _sendGameResumedCoroutine = null;
+                    }
+                    else
+                    {
+                        yield return _sendGameResumedCoroutine;
+                    }
+
+                    if (string.IsNullOrEmpty(_csrfToken))
+                    {
+                        LastSubmissionError = SubmissionErrorType.CSRFTokenError;
+                        HyperDebug.LogWarning("Final score submit blocked: CSRF token still unavailable after refresh attempt. Retrying... [CSRF_TOKEN_ERROR]");
+                        _currentRetryCount++;
+                        _gameManager?.GameOverModalComponent?.UpdateAttemptCount(_currentRetryCount, MAX_RETRY_COUNT);
+
+                        if (_currentRetryCount < MAX_RETRY_COUNT)
+                        {
+                            yield return new WaitForSecondsRealtime(1f);
+                        }
+
+                        continue;
+                    }
+                }
+
                 // Sending final score via WebSocket
                 _finalScoreSubmitted = false;
                 _isWaitingForFinalScoreResponse = true;
@@ -975,6 +1138,12 @@ namespace Hyper.Internal.Managers
         private readonly WaitForSeconds _scoreSendInterval = new WaitForSeconds(1f);
         private bool _isWaitingForFinalScoreResponse;
         private bool _finalScoreSubmitted;
+        private bool _isWaitingForTokenLogEmitted;
+        /// <summary>
+        /// True while a score batch is being encrypted/sent. Prevents overlapping sends and
+        /// lets <see cref="SendScoresInBatch"/> skip a tick instead of draining pending scores mid-flight.
+        /// </summary>
+        private bool _scoreBatchSendInProgress;
 
         public void StartSendingScores()
         {
@@ -1006,6 +1175,28 @@ namespace Hyper.Internal.Managers
                 {
                     int pendingCount = _dataManager?.PendingScores?.Count ?? 0;
                     HyperDebug.Log($"[Score] Socket disconnected - accumulating scores for offline batch. PendingCount={pendingCount}");
+                    _isWaitingForTokenLogEmitted = false;
+                    yield return _scoreSendInterval;
+                    continue;
+                }
+
+                if (string.IsNullOrEmpty(_csrfToken))
+                {
+                    int pendingCount = _dataManager?.PendingScores?.Count ?? 0;
+                    if (!_isWaitingForTokenLogEmitted)
+                    {
+                        HyperDebug.LogWarning($"[Score] CSRF token unavailable - pausing score sends and batching until token refresh. PendingCount={pendingCount}");
+                        _isWaitingForTokenLogEmitted = true;
+                    }
+
+                    yield return _scoreSendInterval;
+                    continue;
+                }
+
+                if (_scoreBatchSendInProgress)
+                {
+                    int pendingCount = _dataManager?.PendingScores?.Count ?? 0;
+                    HyperDebug.LogWarning($"[Score] Batch send in progress; skipping this tick to avoid overlapping submits. PendingCount={pendingCount}");
                     yield return _scoreSendInterval;
                     continue;
                 }
@@ -1028,6 +1219,7 @@ namespace Hyper.Internal.Managers
                 }
                 else
                 {
+                    _isWaitingForTokenLogEmitted = false;
                     HyperDebug.Log("[Score] No pending scores to send in this tick.");
                 }
 
@@ -1035,10 +1227,75 @@ namespace Hyper.Internal.Managers
             }
         }
 
+        /// <summary>
+        /// Sorts a batch in chronological order (oldest to newest) by score time.
+        /// Null entries and entries without snapshots are pushed to the end.
+        /// </summary>
+        private static void SortScoresByScoreTimeAscending(List<ScoreData> scores)
+        {
+            if (scores == null || scores.Count <= 1) return;
+            scores.Sort(CompareScoresByScoreTimeAscending);
+        }
+
+        private static int CompareScoresByScoreTimeAscending(ScoreData left, ScoreData right)
+        {
+            if (ReferenceEquals(left, right)) return 0;
+            if (left == null) return 1;
+            if (right == null) return -1;
+
+            bool leftHasSnapshot = left.scoreSnapshot != null;
+            bool rightHasSnapshot = right.scoreSnapshot != null;
+
+            if (!leftHasSnapshot && !rightHasSnapshot)
+            {
+                return left.cumulativeScore.CompareTo(right.cumulativeScore);
+            }
+            if (!leftHasSnapshot) return 1;
+            if (!rightHasSnapshot) return -1;
+
+            int byTime = left.scoreSnapshot.scoreTime.CompareTo(right.scoreSnapshot.scoreTime);
+            if (byTime != 0) return byTime;
+
+            return left.cumulativeScore.CompareTo(right.cumulativeScore);
+        }
+
         private void SendScoresOverWebSocket(List<ScoreData> scores)
         {
             if (scores == null || scores.Count == 0) return;
 
+            SortScoresByScoreTimeAscending(scores);
+
+            ScoreData firstSortedScore = null;
+            ScoreData lastSortedScore = null;
+            for (int i = 0; i < scores.Count; i++)
+            {
+                if (scores[i] != null)
+                {
+                    firstSortedScore = scores[i];
+                    break;
+                }
+            }
+            for (int i = scores.Count - 1; i >= 0; i--)
+            {
+                if (scores[i] != null)
+                {
+                    lastSortedScore = scores[i];
+                    break;
+                }
+            }
+
+            if (firstSortedScore != null && lastSortedScore != null)
+            {
+                float firstTime = firstSortedScore.scoreSnapshot?.scoreTime ?? -1f;
+                float lastTime = lastSortedScore.scoreSnapshot?.scoreTime ?? -1f;
+                HyperDebug.Log(
+                    $"[Score] Sorted score batch by time ascending. " +
+                    $"FirstTime={firstTime}, LastTime={lastTime}, " +
+                    $"FirstCumulativeScore={firstSortedScore.cumulativeScore}, LastCumulativeScore={lastSortedScore.cumulativeScore}, " +
+                    $"BatchSize={scores.Count}"
+                );
+            }
+
             // Don't send if socket is not connected - prevents sending with expired tokens
             // and ensures we wait for reconnection to get fresh token via SendGameResumed()
             if (!isSocketConnected)
@@ -1048,6 +1305,27 @@ namespace Hyper.Internal.Managers
                 return;
             }
 
+            if (string.IsNullOrEmpty(_csrfToken))
+            {
+                int lastScore = scores[scores.Count - 1].cumulativeScore;
+                HyperDebug.LogWarning($"[Score] Cannot send scores: CSRF token unavailable. LastBatchCumulativeScore={lastScore} [ErrorType=CSRFTokenError]");
+                return;
+            }
+
+            if (_scoreBatchSendInProgress)
+            {
+                HyperDebug.LogWarning("[Score] Overlapping SendScoresOverWebSocket — re-queueing batch at front of pending.");
+                if (_dataManager == null) _dataManager = HyperRuntime.DataManager;
+                if (_dataManager?.PendingScores != null && scores.Count > 0)
+                {
+                    _dataManager.PendingScores.InsertRange(0, scores);
+                }
+
+                scores.Clear();
+                return;
+            }
+
+            _scoreBatchSendInProgress = true;
             try
             {
                 // Clone the batch into standalone ScoreData instances
@@ -1075,12 +1353,27 @@ namespace Hyper.Internal.Managers
                     return;
                 }
 
-                var message = new WebSocketScoreMessage(_cachedSessionId, _csrfToken, encryptedData);
+                string tokenUsedForSend = _csrfToken;
+                var message = new WebSocketScoreMessage(_cachedSessionId, tokenUsedForSend, encryptedData);
                 string json = JsonConvert.SerializeObject(message);
-                int csrfLength = string.IsNullOrEmpty(_csrfToken) ? 0 : _csrfToken.Length;
+                int csrfLength = string.IsNullOrEmpty(tokenUsedForSend) ? 0 : tokenUsedForSend.Length;
                 int lastCumulativeScore = scores[scores.Count - 1].cumulativeScore;
                 HyperDebug.Log($"[Score] Sending score batch. LastCumulativeScore={lastCumulativeScore}, BatchSize={scores.Count}, SessionId={_cachedSessionId}, CsrfLength={csrfLength}");
                 SendWebSocketMessage(json);
+
+                // Strict token-gated flow: invalidate only the token we sent. If scoreUpdated ran
+                // re-entrantly during SendWebSocketMessage (WebGL) and refreshed _csrfToken, do not wipe it.
+                if (string.Equals(_csrfToken, tokenUsedForSend, StringComparison.Ordinal))
+                {
+                    _csrfToken = null;
+                    _isWaitingForTokenLogEmitted = false;
+                    HyperDebug.Log("[CSRF] Token invalidated after score batch send. Awaiting fresh token from scoreUpdated.");
+                }
+                else
+                {
+                    _isWaitingForTokenLogEmitted = false;
+                    HyperDebug.Log("[CSRF] Token refreshed during batch send; preserving new token (re-entrancy-safe).");
+                }
             }
             catch (Exception ex)
             {
@@ -1089,6 +1382,7 @@ namespace Hyper.Internal.Managers
             }
             finally
             {
+                _scoreBatchSendInProgress = false;
                 if (_dataManager == null) _dataManager = HyperRuntime.DataManager;
                 _dataManager?.ReturnScoreDataToPool(scores);
                 scores?.Clear();
@@ -1210,7 +1504,7 @@ namespace Hyper.Internal.Managers
             string gameSlug = _gameManager.Config.GameSlug;
 
 #if UNITY_WEBGL && !UNITY_EDITOR
-            FetchAndCacheTutorials(gameSlug, gameObject.name);
+            FetchAndCacheTutorials(GetServerUrl(), gameSlug, gameObject.name);
 #else
             StartCoroutine(SimulateTutorialFetch());
 #endif

package/Runtime/Internal/Managers/DataManager.cs

@@ -134,6 +134,7 @@ namespace Hyper.Internal.Managers
         internal TutorialData TutorialData { get; private set; }
         internal bool HasReferencedTutorialResources { get; private set; }
         private const int SCORE_POOL_CAPACITY = 15;
+        private bool _gameSessionEndAudioMuted;
 
         internal void ConfigurePlayerSoundSetting()
         {
@@ -141,8 +142,28 @@ namespace Hyper.Internal.Managers
             if (_gameManager == null) _gameManager = HyperRuntime.GameManager;
         }
 
+        /// <summary>
+        /// Mutes all game audio when a session ends (global listener). Idempotent until restored.
+        /// </summary>
+        internal void MuteAudioForGameSessionEnd()
+        {
+            if (_gameSessionEndAudioMuted) return;
+            _gameSessionEndAudioMuted = true;
+            AudioListener.volume = 0f;
+        }
+
+        /// <summary>
+        /// Restores listener volume from the player's sound preference (0 or 1). Used after custom restart.
+        /// </summary>
+        internal void RestoreAudioAfterGameSessionEnd()
+        {
+            if (!_gameSessionEndAudioMuted) return;
+            SetSound(GetSound());
+        }
+
         internal void SetSound(int sound)
         {
+            _gameSessionEndAudioMuted = false;
             PlayerPrefs.SetInt(HyperConstants.SOUND_KEY, sound);
             _eventManager.InvokeSoundChangedEvent(sound == 1);
             AudioListener.volume = sound;

package/Runtime/Internal/Managers/EventManager.cs

@@ -40,6 +40,7 @@ namespace Hyper.Internal.Managers
         internal event Action OnStartDeadlineReached;
         internal event Action OnInternetConnectionLost;
         internal event Action OnInternetConnectionFound;
+        internal event Action OnBackendSocketManuallyClosed;
         internal event Action OnTutorialFetchComplete;
         internal event Action OnTutorialResourcesReferenced;
         internal event Action OnTutorialLoadingComplete;
@@ -81,6 +82,7 @@ namespace Hyper.Internal.Managers
         internal void InvokeCustomRestartEvent() => OnCustomRestart?.Invoke();
         internal void InvokeConnectionLostEvent() => OnInternetConnectionLost?.Invoke();
         internal void InvokeConnectionFoundEvent() => OnInternetConnectionFound?.Invoke();
+        internal void InvokeBackendSocketManuallyClosedEvent() => OnBackendSocketManuallyClosed?.Invoke();
         internal void InvokeTutorialLoadingCompleteEvent() => OnTutorialLoadingComplete?.Invoke();
         internal void InvokeTutorialResourcesReferencedEvent() => OnTutorialResourcesReferenced?.Invoke();
         internal void InvokeTutorialFetchCompleteEvent() => OnTutorialFetchComplete?.Invoke();

package/Runtime/Internal/Managers/GameManager.cs

@@ -120,6 +120,7 @@ namespace Hyper.Internal.Managers
             if (IsBattleMode) return;
 
             _hasGameEnded = true;
+            _dataManager.MuteAudioForGameSessionEnd();
             HyperRuntime.Timer.StopAllTimers();
 
             if (!HyperRuntime.GameContent.IsPracticeMenu)
@@ -845,6 +846,7 @@ namespace Hyper.Internal.Managers
 
             HyperRuntime.Timer.Reset();
             HyperRuntime.DataManager.UpdateScore(0);
+            HyperRuntime.DataManager.RestoreAudioAfterGameSessionEnd();
 
             ShowControlBarElements();
             ShowStartingInstructionModal();
@@ -857,6 +859,7 @@ namespace Hyper.Internal.Managers
         private void EndGameInternal()
         {
             _hasGameEnded = true;
+            _dataManager.MuteAudioForGameSessionEnd();
 
             _eventManager.InvokeGameEndedEvent();
             HyperRuntime.Timer.StopAllTimers();
@@ -999,7 +1002,7 @@ namespace Hyper.Internal.Managers
             _canvasScaler = _canvas.GetComponent<CanvasScaler>();
             _canvasScaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
             _canvasScaler.referenceResolution = new Vector2(1080, 1920);
-            _canvasScaler.matchWidthOrHeight = IsPortrait() ? 0.43f : 0.73f;
+            _canvasScaler.matchWidthOrHeight = IsPortrait() ? 0.43f : 0.63f;
 
             CreateSafeArea();
             CreateBlockerUI();
@@ -1393,6 +1396,7 @@ namespace Hyper.Internal.Managers
         private void ShowTimeUpModalInternal()
         {
             _hasGameEnded = true;
+            _dataManager.MuteAudioForGameSessionEnd();
 
             if (_timeUpModal == null)
             {