app.hypergames.hypersdk 1.11.0-beta.3 → 1.11.0-beta.5

package/CHANGELOG.md

@@ -1,3 +1,23 @@
+# [1.11.0-beta.5](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.4...v1.11.0-beta.5) (2026-08-28)
+
+
+### Bug Fixes
+
+* **replay:** wait for custom restart readiness ([43f1aeb](https://github.com/mvmhyper/hyper-sdk/commit/43f1aeb6a127c8c12dbb8379e7230d64ef5e0763))
+
+
+### Features
+
+* **replay:** add replay pause controls ([b9fb470](https://github.com/mvmhyper/hyper-sdk/commit/b9fb470e65c69e66a8a9611b0caa7e5417b1e4bf))
+* **replay:** update replay control bar assets ([79ce8c0](https://github.com/mvmhyper/hyper-sdk/commit/79ce8c0f1b68129ae5b8bcf18a302117cf11c885))
+
+# [1.11.0-beta.4](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.3...v1.11.0-beta.4) (2026-08-28)
+
+
+### Bug Fixes
+
+* **replay:** align recording with fixed simulation ([ae2b322](https://github.com/mvmhyper/hyper-sdk/commit/ae2b32216a0a9ea125572d788eee3bfd846414b0))
+
 # [1.11.0-beta.3](https://github.com/mvmhyper/hyper-sdk/compare/v1.11.0-beta.2...v1.11.0-beta.3) (2026-08-28)
 
 

package/Runtime/Internal/Core/HyperRuntime.cs

@@ -21,6 +21,7 @@ namespace Hyper.Internal
         private static bool _isInitialized;
         private static bool _isSoftRestarting;
         private static bool _replayRandomResetPending;
+        private static bool _replayCustomRestartPending;
         private static bool _customLoadingComplete;
         private static bool _customLoadingActive;
         private static float _customLoadingProgress;
@@ -33,6 +34,7 @@ namespace Hyper.Internal
         private static EventManager _eventManager;
         private static TimerManager _timerManager;
         private static ReplayManager _replayManager;
+        private static double _fixedSimulationTimeSeconds;
 
         internal static bool IsInitialized => _isInitialized;
         internal static bool IsSoftRestarting
@@ -40,6 +42,7 @@ namespace Hyper.Internal
             get => _isSoftRestarting;
             set => _isSoftRestarting = value;
         }
+        internal static bool IsReplayCustomRestartPending => _replayCustomRestartPending;
         internal static bool CustomLoadingComplete
         {
             get => _customLoadingComplete;
@@ -59,6 +62,7 @@ namespace Hyper.Internal
         internal static EventManager EventManager => _eventManager;
         internal static TimerManager Timer => _timerManager;
         internal static ReplayManager ReplayManager => _replayManager;
+        internal static double FixedSimulationTimeSeconds => _fixedSimulationTimeSeconds;
 
         internal static event Action CustomLoadingStarted
         {
@@ -145,12 +149,12 @@ namespace Hyper.Internal
             if (_settings != null && _settings.useCustomRestartFlow &&
                 _gameManager != null && _eventManager != null)
             {
+                _replayCustomRestartPending = true;
                 _replayManager?.PrepareForRestart();
                 // Custom cleanup may use random streams. Rewind after cleanup, immediately before OnGameStart.
                 DeferReplayRandomReset();
                 _gameManager.ResetUIStateForCustomRestart();
                 _eventManager.InvokeCustomRestartEvent();
-                _isSoftRestarting = false;
                 return;
             }
 
@@ -191,6 +195,21 @@ namespace Hyper.Internal
             _replayRandomResetPending = true;
         }
 
+        internal static void CompleteCustomRestart()
+        {
+            if (!_replayCustomRestartPending || _host == null) return;
+
+            _replayCustomRestartPending = false;
+            _host.StartCoroutine(CompleteReplayCustomRestartNextFrame());
+        }
+
+        private static IEnumerator CompleteReplayCustomRestartNextFrame()
+        {
+            yield return null;
+            _gameManager?.CompleteReplayCustomRestart();
+            _isSoftRestarting = false;
+        }
+
         /// <summary>
         /// Coroutine-based restart that properly unloads all scenes before reloading.
         /// Handles async scene operations and ensures clean state before restart.
@@ -396,6 +415,7 @@ namespace Hyper.Internal
         internal static void FixedTick()
         {
             if (!_isInitialized) return;
+            _fixedSimulationTimeSeconds += Time.fixedDeltaTime;
             _replayManager?.FixedTick();
             _timerManager?.FixedTick();
         }
@@ -430,6 +450,7 @@ namespace Hyper.Internal
             _customLoadingActive = false;
             _customLoadingProgress = 0f;
             _replayRandomResetPending = false;
+            _replayCustomRestartPending = false;
 
             if (_singletonObject != null)
             {
@@ -489,6 +510,8 @@ namespace Hyper.Internal
             _customLoadingActive = false;
             _customLoadingProgress = 0f;
             _replayRandomResetPending = false;
+            _replayCustomRestartPending = false;
+            _fixedSimulationTimeSeconds = 0d;
         }
     }
 }

package/Runtime/Internal/Managers/DataManager.cs

@@ -462,7 +462,7 @@ namespace Hyper.Internal.Managers
 
         private static double GetSimulationTimeSeconds()
         {
-            return Time.fixedTimeAsDouble;
+            return HyperRuntime.FixedSimulationTimeSeconds;
         }
 
         private ScoreData GetPooledScoreData()

package/Runtime/Internal/Managers/GameManager.cs

@@ -191,6 +191,41 @@ namespace Hyper.Internal.Managers
             Resources.UnloadUnusedAssets();
         }
 
+        internal void PauseReplay()
+        {
+            if (!IsReplayMode || !_hasGameStarted || _isPaused || _hasGameEnded)
+            {
+                return;
+            }
+
+            _isPaused = true;
+            _savedReplayTimeScale = Time.timeScale > 0f
+                ? Time.timeScale
+                : ReplaySessionState.PlaybackSpeed;
+            Time.timeScale = 0f;
+            HyperRuntime.Timer.PauseGameplayTimers();
+
+            _previousTimeScale = 0f;
+            _eventManager.InvokeTimeScaleFrozenEvent();
+            ReplayPresentationCanvas.SetSeekingLayer(false);
+            SetBlockerActive(true);
+            ShowReplayPauseModal();
+        }
+
+        internal void ResumeReplay()
+        {
+            if (!IsReplayMode || !_isPaused || _hasGameEnded) return;
+
+            _isPaused = false;
+            HidePauseModals();
+            Time.timeScale = _savedReplayTimeScale > 0f ? _savedReplayTimeScale : 1f;
+            HyperRuntime.Timer.ResumeGameTimersAfterPause();
+
+            _previousTimeScale = Time.timeScale;
+            _eventManager.InvokeTimeScaleResumedEvent();
+            ReplayPresentationCanvas.SetSeekingLayer(ReplaySessionState.IsSeeking);
+        }
+
         internal void ResumeGame()
         {
             _isPaused = false;
@@ -222,51 +257,7 @@ namespace Hyper.Internal.Managers
         private void HandleReplayFocus(bool hasFocus)
         {
             if (!_hasGameStarted || _hasGameEnded) return;
-
-            if (!hasFocus && _replayFocusResumeCoroutine != null)
-            {
-                StopCoroutine(_replayFocusResumeCoroutine);
-                _replayFocusResumeCoroutine = null;
-            }
-
-            if (!hasFocus && !_replayFocusSuspended)
-            {
-                _replayFocusSuspended = true;
-                _savedReplayTimeScale = Time.timeScale;
-                Time.timeScale = 0f;
-                HyperRuntime.Timer.PauseGameplayTimers();
-
-                // WebGL may stop producing frames immediately after focus loss,
-                // so suspend replay timing here instead of waiting for Update.
-                _previousTimeScale = 0f;
-                _eventManager.InvokeTimeScaleFrozenEvent();
-                HyperDebug.Log("Time scale frozen event invoked");
-            }
-            else if (hasFocus && _replayFocusSuspended)
-            {
-                if (_replayFocusResumeCoroutine == null)
-                {
-                    _replayFocusResumeCoroutine = StartCoroutine(ResumeReplayAfterFocus());
-                }
-            }
-        }
-
-        private IEnumerator ResumeReplayAfterFocus()
-        {
-            // WebGL reports focus before Unity refreshes its unscaled clock. Keep
-            // gameplay and replay frozen briefly while session time continues.
-            yield return new WaitForSecondsRealtime(1f);
-
-            _replayFocusResumeCoroutine = null;
-            if (!_replayFocusSuspended || _hasGameEnded) yield break;
-
-            _replayFocusSuspended = false;
-            Time.timeScale = _savedReplayTimeScale > 0f ? _savedReplayTimeScale : 1f;
-            HyperRuntime.Timer.ResumeGameTimersAfterPause();
-
-            _previousTimeScale = Time.timeScale;
-            _eventManager.InvokeTimeScaleResumedEvent();
-            HyperDebug.Log("Time scale resumed event invoked");
+            if (!hasFocus) PauseReplay();
         }
 
         void HandlePauseState(bool shouldPause)
@@ -552,7 +543,7 @@ namespace Hyper.Internal.Managers
 
         internal void ShowStartGameDeadline(int timeLeft)
         {
-            if (_hasGameStarted || !IsInGameScene) return;
+            if (_hasGameStarted || !IsInGameScene || IsReplayMode) return;
 
             EnsureStartGameDeadlineBar();
             _eventManager.OnSessionAboutToExpire += ChangeDeadlineColorToRed;
@@ -728,7 +719,6 @@ namespace Hyper.Internal.Managers
         private bool _isPortrait;
         private float _previousTimeScale = 1f;
         private float _savedTimeScaleBeforePause = 1f;
-        private bool _replayFocusSuspended;
         private float _savedReplayTimeScale = 1f;
 
         #endregion
@@ -1077,7 +1067,6 @@ namespace Hyper.Internal.Managers
             _gameStartRequested = false;
             _hasGameEnded = false;
             _replayEndHandled = false;
-            _replayFocusSuspended = false;
             _isPaused = false;
             _isFrozenBeforePause = false;
 
@@ -1088,6 +1077,12 @@ namespace Hyper.Internal.Managers
             ShowControlBarElements();
             _replayControllerComponent?.ResetForReplayRestart();
 
+            if (IsReplayMode && HyperRuntime.IsReplayCustomRestartPending)
+            {
+                HideStartingInstructionModal();
+                return;
+            }
+
             if (IsReplayMode && ReplaySessionState.IsSeeking)
             {
                 HideStartingInstructionModal();
@@ -1099,6 +1094,20 @@ namespace Hyper.Internal.Managers
             }
         }
 
+        internal void CompleteReplayCustomRestart()
+        {
+            if (!IsReplayMode || _gameStartRequested || _hasGameStarted || _hasGameEnded) return;
+
+            if (ReplaySessionState.IsSeeking)
+            {
+                StartCoroutine(StartSeekingReplayWhenReady());
+            }
+            else
+            {
+                ShowStartingInstructionModal();
+            }
+        }
+
         #endregion
 
         #region Game End Logic
@@ -1140,7 +1149,6 @@ namespace Hyper.Internal.Managers
 
             _replayEndHandled = true;
             _hasGameEnded = true;
-            _replayFocusSuspended = false;
             Time.timeScale = 1f;
             _eventManager.InvokeGameEndedEvent();
             HyperRuntime.Timer.StopAllTimers();
@@ -1162,10 +1170,12 @@ namespace Hyper.Internal.Managers
                 _eventManager.InvokeGameEndedEvent();
             }
 
+            _isPaused = false;
             Time.timeScale = 1f;
             HyperRuntime.Timer.StopAllTimers();
             _dataManager.StopCapturingScores();
             HyperRuntime.BackendManager.StopSendingScores();
+            HidePauseModals();
             _replayControllerComponent?.SetReplayEnded();
             ReplaySessionState.Clear();
             ReplayPresentationCanvas.DestroyCurrent();
@@ -1276,8 +1286,8 @@ namespace Hyper.Internal.Managers
         private GameObject _replayControllerObject;
         private ReplayController _replayControllerComponent;
         private GameObject _replayOverModal;
+        private GameObject _replayPausedModal;
         private Coroutine _replayConnectionCheckCoroutine;
-        private Coroutine _replayFocusResumeCoroutine;
 
         private GameObject _connectionStatusBar;
         private GameObject _startGameDeadlineStatusBar;
@@ -1507,6 +1517,30 @@ namespace Hyper.Internal.Managers
             _replayOverModal.transform.SetAsLastSibling();
         }
 
+        private void ShowReplayPauseModal()
+        {
+            if (_replayPausedModal == null)
+            {
+                if (_canvas == null) CreateCanvas();
+                GameObject prefab = Resources.Load<GameObject>("UIPrefabs/ReplayPausedModal");
+                if (prefab == null)
+                {
+                    HyperDebug.LogWarning("[GameManager] ReplayPausedModal prefab not found.");
+                    ResumeReplay();
+                    return;
+                }
+
+                _replayPausedModal = InstantiateModal(prefab);
+                if (_replayPausedModal.GetComponent<ReplayPausedModal>() == null)
+                {
+                    _replayPausedModal.AddComponent<ReplayPausedModal>();
+                }
+            }
+
+            _replayPausedModal.SetActive(true);
+            _replayPausedModal.transform.SetAsLastSibling();
+        }
+
         private void EnsureConnectionStatusBar()
         {
             if (_connectionStatusBar != null) return;
@@ -1755,6 +1789,7 @@ namespace Hyper.Internal.Managers
         internal void HidePauseModals()
         {
             SetBlockerActive(false);
+            if (_replayPausedModal != null) _replayPausedModal.SetActive(false);
             if (_battleGamePausedModal != null) _battleGamePausedModal.SetActive(false);
             if (_practicePausedModal != null) _practicePausedModal.SetActive(false);
             if (_battleGamePausedLandscapeModal != null) _battleGamePausedLandscapeModal.SetActive(false);

package/Runtime/Internal/Managers/TimeManager.cs

@@ -129,7 +129,7 @@ namespace Hyper.Internal.Managers
 
         public void ResumeGameTimersAfterPause()
         {
-            if (_gameManager.IsBattleMode)
+            if (_gameManager.IsBattleMode && !_gameManager.IsReplayMode)
             {
                 StartBattle();
             }

package/Runtime/Internal/Replay/ReplaySessionState.cs

@@ -31,6 +31,7 @@ namespace Hyper.Internal
         public static event Action<float> SeekCompleted;
 
         private static bool _seekPlaybackReady;
+        private static bool _watchAgainAutoStartPending;
 
         public static void Configure(
             string playerName,
@@ -51,6 +52,7 @@ namespace Hyper.Internal
             IsSeeking = false;
             SeekTarget01 = 0f;
             _seekPlaybackReady = false;
+            _watchAgainAutoStartPending = false;
             HasEnded = false;
         }
 
@@ -124,6 +126,7 @@ namespace Hyper.Internal
             if (!IsActive || !IsSeeking) return;
             Progress01 = 0f;
             _seekPlaybackReady = false;
+            _watchAgainAutoStartPending = false;
             HasEnded = false;
         }
 
@@ -142,9 +145,17 @@ namespace Hyper.Internal
             IsSeeking = false;
             SeekTarget01 = 0f;
             _seekPlaybackReady = false;
+            _watchAgainAutoStartPending = true;
             HasEnded = false;
         }
 
+        public static bool ConsumeWatchAgainAutoStart()
+        {
+            bool pending = _watchAgainAutoStartPending;
+            _watchAgainAutoStartPending = false;
+            return pending;
+        }
+
         public static void Clear()
         {
             IsActive = false;
@@ -160,6 +171,7 @@ namespace Hyper.Internal
             IsSeeking = false;
             SeekTarget01 = 0f;
             _seekPlaybackReady = false;
+            _watchAgainAutoStartPending = false;
             HasEnded = false;
             SeekCompleted = null;
         }

package/Runtime/Internal/UI/Components/ReplayController.cs

@@ -15,7 +15,7 @@ namespace Hyper.Internal
         [SerializeField] private Slider progressSlider;
         [SerializeField] private TextMeshProUGUI replayLabel;
         [SerializeField] private RawImage playerAvatar;
-        [SerializeField] private Button exitButton;
+        [SerializeField] private Button pauseButton;
         [SerializeField] private Button playbackSpeedButton;
         [SerializeField] private TextMeshProUGUI playbackSpeedLabel;
         [SerializeField] private float[] playbackSpeeds = { 1.5f, 2f, 3f, 4f, 5f, 1f };
@@ -41,7 +41,7 @@ namespace Hyper.Internal
             ConfigureSeekSnapshot();
             ApplyInitialPlaybackSpeed();
             ReplaySessionState.SeekCompleted += RestorePlaybackAfterSeek;
-            if (exitButton != null) exitButton.onClick.AddListener(ExitReplay);
+            if (pauseButton != null) pauseButton.onClick.AddListener(PauseReplay);
             if (playbackSpeedButton != null) playbackSpeedButton.onClick.AddListener(CyclePlaybackSpeed);
         }
 
@@ -94,7 +94,7 @@ namespace Hyper.Internal
 
         private void OnDestroy()
         {
-            if (exitButton != null) exitButton.onClick.RemoveListener(ExitReplay);
+            if (pauseButton != null) pauseButton.onClick.RemoveListener(PauseReplay);
             if (playbackSpeedButton != null) playbackSpeedButton.onClick.RemoveListener(CyclePlaybackSpeed);
             ReplaySessionState.SeekCompleted -= RestorePlaybackAfterSeek;
             seekInput?.Clear();
@@ -124,7 +124,7 @@ namespace Hyper.Internal
 
         internal void SetReplayEnded()
         {
-            if (exitButton != null) exitButton.interactable = false;
+            if (pauseButton != null) pauseButton.interactable = false;
             if (playbackSpeedButton != null) playbackSpeedButton.interactable = false;
             if (progressSlider != null) progressSlider.interactable = false;
             if (seekLoadingOverlay != null) seekLoadingOverlay.SetActive(false);
@@ -158,10 +158,9 @@ namespace Hyper.Internal
             SetSeekingPresentation(ReplaySessionState.IsSeeking);
         }
 
-        private void ExitReplay()
+        private void PauseReplay()
         {
-            if (exitButton != null) exitButton.interactable = false;
-            HyperRuntime.GameManager?.ExitReplayEarly();
+            HyperRuntime.GameManager?.PauseReplay();
         }
 
         private void CyclePlaybackSpeed()
@@ -268,7 +267,7 @@ namespace Hyper.Internal
                 playbackSpeedButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
             }
 
-            if (exitButton != null) exitButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
+            if (pauseButton != null) pauseButton.interactable = !isSeeking && !ReplaySessionState.HasEnded;
             if (!isSeeking) ClearSeekSnapshot();
         }
 
@@ -341,7 +340,12 @@ namespace Hyper.Internal
         private void AutoBindReferences()
         {
             if (progressSlider == null) progressSlider = GetComponentInChildren<Slider>(true);
-            if (exitButton == null) exitButton = GetComponentInChildren<Button>(true);
+
+            Button[] buttons = GetComponentsInChildren<Button>(true);
+            for (int i = 0; i < buttons.Length; i++)
+            {
+                if (pauseButton == null && buttons[i].name == "PauseButton") pauseButton = buttons[i];
+            }
 
             TextMeshProUGUI[] labels = GetComponentsInChildren<TextMeshProUGUI>(true);
             for (int i = 0; replayLabel == null && i < labels.Length; i++)

package/Runtime/Internal/UI/Modals/ReplayPausedModal.cs

@@ -0,0 +1,142 @@
+using TMPro;
+using UnityEngine;
+using UnityEngine.UI;
+
+namespace Hyper.Internal
+{
+    internal sealed class ReplayPausedModal : MonoBehaviour
+    {
+        [SerializeField] private TextMeshProUGUI scoreValue;
+        [SerializeField] private TextMeshProUGUI scoreOwnerName;
+        [SerializeField] private TextMeshProUGUI soundText;
+        [SerializeField] private Sprite soundIconOn;
+        [SerializeField] private Sprite soundIconOff;
+        [SerializeField] private Image soundIcon;
+        [SerializeField] private GameObject restartButton;
+        [SerializeField] private Button resumeButton;
+        [SerializeField] private Button exitButton;
+        [SerializeField] private Button soundButton;
+        [SerializeField] private Button restartActionButton;
+
+        private bool handled;
+
+        private void Awake()
+        {
+            AutoBindButtons();
+            resumeButton?.onClick.AddListener(ResumeReplay);
+            exitButton?.onClick.AddListener(ExitReplay);
+            soundButton?.onClick.AddListener(ToggleSound);
+            restartActionButton?.onClick.AddListener(RestartReplay);
+        }
+
+        private void OnEnable()
+        {
+            handled = false;
+            SetButtonsInteractable(true);
+
+            if (scoreValue != null)
+            {
+                scoreValue.text = (HyperRuntime.DataManager?.CurrentScore ?? 0).ToString("N0");
+            }
+
+            if (scoreOwnerName != null)
+            {
+                scoreOwnerName.text = FormatScoreOwner(ReplaySessionState.PlayerName);
+            }
+
+            UpdateSoundPresentation();
+        }
+
+        private void OnDestroy()
+        {
+            resumeButton?.onClick.RemoveListener(ResumeReplay);
+            exitButton?.onClick.RemoveListener(ExitReplay);
+            soundButton?.onClick.RemoveListener(ToggleSound);
+            restartActionButton?.onClick.RemoveListener(RestartReplay);
+        }
+
+        public void ResumeReplay()
+        {
+            if (handled) return;
+            handled = true;
+            SetButtonsInteractable(false);
+            HyperRuntime.GameManager?.ResumeReplay();
+        }
+
+        public void ExitReplay()
+        {
+            if (handled) return;
+            handled = true;
+            SetButtonsInteractable(false);
+            HyperRuntime.GameManager?.ExitReplayEarly();
+        }
+
+        public void ToggleSound()
+        {
+            if (handled || HyperRuntime.DataManager == null) return;
+
+            int sound = HyperRuntime.DataManager.GetSound() == 1 ? 0 : 1;
+            HyperRuntime.DataManager.SetSound(sound);
+            UpdateSoundPresentation();
+        }
+
+        public void RestartReplay()
+        {
+            if (handled) return;
+            handled = true;
+            SetButtonsInteractable(false);
+            HyperRuntime.RestartReplaySession();
+        }
+
+        internal static string FormatScoreOwner(string playerName)
+        {
+            string normalizedName = (playerName ?? string.Empty).Trim().TrimStart('@');
+            return string.IsNullOrEmpty(normalizedName)
+                ? "PLAYER'S SCORE"
+                : $"@{normalizedName.ToUpperInvariant()}'S SCORE";
+        }
+
+        private void UpdateSoundPresentation()
+        {
+            bool isSoundOn = HyperRuntime.DataManager == null || HyperRuntime.DataManager.GetSound() == 1;
+            if (soundText != null) soundText.text = isSoundOn ? "Sound On" : "Sound Off";
+            if (soundIcon != null) soundIcon.sprite = isSoundOn ? soundIconOn : soundIconOff;
+        }
+
+        private void AutoBindButtons()
+        {
+            Button[] buttons = GetComponentsInChildren<Button>(true);
+            for (int i = 0; i < buttons.Length; i++)
+            {
+                switch (buttons[i].name)
+                {
+                    case "Resume":
+                        if (resumeButton == null) resumeButton = buttons[i];
+                        break;
+                    case "Exit":
+                        if (exitButton == null) exitButton = buttons[i];
+                        break;
+                    case "SoundButton":
+                        if (soundButton == null) soundButton = buttons[i];
+                        break;
+                    case "RestartButton":
+                        if (restartActionButton == null) restartActionButton = buttons[i];
+                        break;
+                }
+            }
+
+            if (restartButton == null && restartActionButton != null)
+            {
+                restartButton = restartActionButton.gameObject;
+            }
+        }
+
+        private void SetButtonsInteractable(bool interactable)
+        {
+            if (resumeButton != null) resumeButton.interactable = interactable;
+            if (exitButton != null) exitButton.interactable = interactable;
+            if (soundButton != null) soundButton.interactable = interactable;
+            if (restartActionButton != null) restartActionButton.interactable = interactable;
+        }
+    }
+}

package/Runtime/Internal/UI/Modals/ReplayPausedModal.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b26c59e3565391f4daa22e917b6156b4

package/Runtime/Internal/UI/Modals/StartingInstructionModal.cs

@@ -59,6 +59,7 @@ namespace Hyper.Internal
         {
             float elapsed = 0f;
             float delay = Mathf.Max(0f, replayAutoStartDelay);
+            if (ReplaySessionState.ConsumeWatchAgainAutoStart()) delay *= 0.5f;
             while (elapsed < delay)
             {
                 if (Application.isFocused) elapsed += Time.unscaledDeltaTime;

package/Runtime/Public/Core/HyperSDK.cs

@@ -226,6 +226,12 @@ namespace Hyper
         /// </summary>
         void ExitPracticeMenu();
 
+        /// <summary>
+        /// Notifies the SDK that game-owned custom restart cleanup is complete.
+        /// Replay Watch Again and seeking wait for this signal before restarting playback.
+        /// </summary>
+        void CompleteCustomRestart();
+
         // Lives Management (only available when ControlBarLayout is HeartsLeft)
         /// <summary>
         /// Initialize the lives system with a maximum and optional initial value.
@@ -616,6 +622,8 @@ namespace Hyper
 
         public void ExitPracticeMenu() => Manager?.ExitPracticeMenu();
 
+        public void CompleteCustomRestart() => HyperRuntime.CompleteCustomRestart();
+
         public void InitializeLives(int maxLives, int initialLives = -1) => Manager?.InitializeLives(maxLives, initialLives);
         public void SetLives(int lives) => Manager?.SetLives(lives);
         public void AddLife() => Manager?.AddLife();