Stabilize browser playback after truncated replay loads

Current logic-generated replay files can end with a truncated length-delimited protobuf frame while still containing thousands of valid frames. The playback UI treated that as a hard load failure, kept the partially parsed reader alive, and let Play resurrect the failed state. Repeated WebGL loads also retained old readers and blob URLs, increasing heap pressure.

Constraint: Website-facing WebGL API must remain compatible
Rejected: Treat all truncated replays as hard failures | would reject currently usable logic-generated replays
Confidence: high
Scope-risk: moderate
Directive: Do not reintroduce failed-reader recovery without testing repeated truncated WebGL loads
Tested: MessageReader parses latest v9 truncated sample as 11865-frame partial load
Tested: MessageReader parses old v7 sample as 1201 complete frames
Tested: Empty, bad magic, and unknown version samples stay failed with zero buffered frames
Tested: Unity Playback WebGL build completed successfully
Tested: Unity-Playback-WebGL.zip matches playback directory SHA256 for all 17 files
Tested: dotnet format whitespace Unity-Playback scripts --verify-no-changes
Tested: WebGL root/live/playback/trial HTTP smoke returned 200 from interface Unity-WebGL root
Not-tested: Browser upload loop on deployed site

Author: zyfkid

interface/Unity/Unity-Playback/Assets/Plugins/WebGL/THUAI9WebGLBridge.jslib

@@ -1,6 +1,8 @@
 mergeInto(LibraryManager.library, {
   $THUAI9WebGLBridge: {
     maxBase64Bytes: 16 * 1024 * 1024,
+    maxRemotePlaybackBytes: 64 * 1024 * 1024,
+    activePlaybackObjectUrl: null,
     sendMessage: function (gameObjectName, methodName, payload) {
       if (typeof SendMessage === 'function') { SendMessage(gameObjectName, methodName, payload || ''); return; }
       var unityInstance = window.unityInstance || window.THUAIGameInstance || window.gameInstance || (typeof Module !== 'undefined' ? Module : null);
@@ -35,13 +37,47 @@ mergeInto(LibraryManager.library, {
     dispatchCustomEvent: function (eventName, detail) {
       if (typeof window.CustomEvent === 'function') { window.dispatchEvent(new CustomEvent(eventName, { detail: detail })); return; }
       var event = document.createEvent('CustomEvent'); event.initCustomEvent(eventName, false, false, detail); window.dispatchEvent(event);
+    },
+    revokeActivePlaybackObjectUrl: function () {
+      if (!THUAI9WebGLBridge.activePlaybackObjectUrl) return;
+      try { URL.revokeObjectURL(THUAI9WebGLBridge.activePlaybackObjectUrl); } catch (_) {}
+      THUAI9WebGLBridge.activePlaybackObjectUrl = null;
+    },
+    isTerminalPlaybackStatus: function (payload) {
+      if (!payload) return false;
+      try {
+        var status = typeof payload === 'string' ? JSON.parse(payload) : payload;
+        if (status && status.loaded) return true;
+        var text = status && status.statusText ? String(status.statusText) : '';
+        return text && text.indexOf('正在') < 0;
+      } catch (_) {
+        return false;
+      }
     }
   },
   THUAI9_SelectPlaybackFile__deps: ['$THUAI9WebGLBridge'],
   THUAI9_SelectPlaybackFile: function (gameObjectNamePtr, callbackNamePtr) {
     var gameObjectName = UTF8ToString(gameObjectNamePtr); var callbackName = UTF8ToString(callbackNamePtr);
     var input = document.createElement('input'); input.type = 'file'; input.accept = '.thuaipb,application/octet-stream'; input.style.display = 'none';
-    input.onchange = function () { var file = input.files && input.files[0]; if (!file) { input.remove(); return; } var url = URL.createObjectURL(file); var payload = JSON.stringify({ url: url, name: file.name || 'playback.thuaipb', size: file.size || 0 }); THUAI9WebGLBridge.sendMessage(gameObjectName, callbackName, payload); THUAI9WebGLBridge.dispatchCustomEvent('thuai9-playback-file-selected', { url: url, name: file.name, size: file.size }); input.remove(); };
+    input.onchange = function () {
+      var file = input.files && input.files[0];
+      if (!file) { input.remove(); return; }
+      var size = file.size || 0;
+      var name = file.name || 'playback.thuaipb';
+      if (size > THUAI9WebGLBridge.maxRemotePlaybackBytes) {
+        THUAI9WebGLBridge.dispatchCustomEvent('thuai9-playback-error', 'file-too-large:' + size);
+        input.remove();
+        return;
+      }
+
+      THUAI9WebGLBridge.revokeActivePlaybackObjectUrl();
+      var url = URL.createObjectURL(file);
+      THUAI9WebGLBridge.activePlaybackObjectUrl = url;
+      var payload = JSON.stringify({ url: url, name: name, size: size });
+      THUAI9WebGLBridge.sendMessage(gameObjectName, callbackName, payload);
+      THUAI9WebGLBridge.dispatchCustomEvent('thuai9-playback-file-selected', { url: url, name: name, size: size });
+      input.remove();
+    };
     document.body.appendChild(input); input.click();
   },
   THUAI9_ClearDevelopmentConsole: function () {
@@ -83,5 +119,8 @@ mergeInto(LibraryManager.library, {
     var eventName = UTF8ToString(eventNamePtr); var payload = UTF8ToString(payloadPtr);
     THUAI9WebGLBridge.dispatchCustomEvent('thuai9-unity-event', { eventName: eventName, payload: payload });
     THUAI9WebGLBridge.dispatchCustomEvent('thuai9-' + eventName, payload);
+    if (eventName === 'playback-error' || (eventName === 'playback-status' && THUAI9WebGLBridge.isTerminalPlaybackStatus(payload))) {
+      THUAI9WebGLBridge.revokeActivePlaybackObjectUrl();
+    }
   }
 });

interface/Unity/Unity-Playback/Assets/Scripts/Playback/MessageReader.cs

@@ -7,6 +7,17 @@
 
 namespace THUAI9.Unity.Playback
 {
+    public sealed class PlaybackFileIncompleteException : Exception
+    {
+        public PlaybackFileIncompleteException(string message, int parsedFrameCount)
+            : base(message)
+        {
+            ParsedFrameCount = parsedFrameCount;
+        }
+
+        public int ParsedFrameCount { get; }
+    }
+
     /// <summary>
     /// THUAI9 ????????
     /// ?????????
@@ -28,6 +39,9 @@ public class MessageReader
         public uint PlayerCount { get; private set; }
         public byte FileVersion { get; private set; }
         public bool IsLegacyVersion => FileVersion != 0 && FileVersion != PlayBackConstant.FILE_VERSION;
+        public bool IsIncompleteTail { get; private set; }
+        public string LoadWarning { get; private set; }
+        public int DecompressedByteCount { get; private set; }
 
         public void LoadData(byte[] data)
         {
@@ -36,8 +50,12 @@ public void LoadData(byte[] data)
                 throw new ObjectDisposedException(nameof(MessageReader));
             }
 
-            messages.Clear();
-            currentMsgIndex = -1;
+            ResetLoadedData();
+
+            if (data == null || data.Length < 12)
+            {
+                throw new FormatException("回放文件头不完整。");
+            }
 
             using (var headerStream = new MemoryStream(data))
             using (var headerReader = new BinaryReader(headerStream))
@@ -65,17 +83,17 @@ public void LoadData(byte[] data)
             byte[] compressedData = new byte[data.Length - headerSize];
             Array.Copy(data, headerSize, compressedData, 0, compressedData.Length);
 
-            using (var compressedStream = new MemoryStream(compressedData))
-            using (var gzipStream = new GZipStream(compressedStream, CompressionMode.Decompress))
-            using (var decompressedStream = new MemoryStream())
-            {
-                gzipStream.CopyTo(decompressedStream);
-                byte[] decompressedData = decompressedStream.ToArray();
+            byte[] decompressedData = DecompressWithLimit(compressedData, out bool gzipEndedEarly);
+            DecompressedByteCount = decompressedData.Length;
 
-                if (!TryLoadIndexedMessages(decompressedData))
-                {
-                    LoadOfficialStreamMessages(decompressedData);
-                }
+            if (!TryLoadIndexedMessages(decompressedData))
+            {
+                LoadOfficialStreamMessages(decompressedData, gzipEndedEarly);
+            }
+            else if (gzipEndedEarly)
+            {
+                IsIncompleteTail = true;
+                LoadWarning = "回放文件末尾缺少 GZip 结束标记，已加载可读取帧。";
             }
 
             Reset();
@@ -151,6 +169,18 @@ public void Dispose()
             disposed = true;
         }
 
+        private void ResetLoadedData()
+        {
+            messages.Clear();
+            currentMsgIndex = -1;
+            TeamCount = 0;
+            PlayerCount = 0;
+            FileVersion = 0;
+            IsIncompleteTail = false;
+            LoadWarning = null;
+            DecompressedByteCount = 0;
+        }
+
         private bool TryLoadIndexedMessages(byte[] decompressedData)
         {
             try
@@ -218,23 +248,131 @@ private bool TryLoadIndexedMessages(byte[] decompressedData)
             }
         }
 
-        private void LoadOfficialStreamMessages(byte[] decompressedData)
+        private void LoadOfficialStreamMessages(byte[] decompressedData, bool gzipEndedEarly)
         {
+            var parsedMessages = new List<MessageToClient>();
+            int offset = 0;
+
+            while (offset < decompressedData.Length)
+            {
+                if (parsedMessages.Count >= PlayBackConstant.MAX_MESSAGE_COUNT)
+                {
+                    throw new FormatException($"Playback message count exceeds {PlayBackConstant.MAX_MESSAGE_COUNT}.");
+                }
+
+                if (!TryReadRawVarint32(decompressedData, ref offset, out int messageLength))
+                {
+                    AcceptOrRejectIncompleteTail(parsedMessages, "回放文件末尾不完整：最后一帧长度字段未写完。");
+                    return;
+                }
+
+                if (messageLength < 0)
+                {
+                    throw new FormatException("回放帧长度字段异常。");
+                }
+
+                if (offset + messageLength > decompressedData.Length)
+                {
+                    int missingBytes = offset + messageLength - decompressedData.Length;
+                    AcceptOrRejectIncompleteTail(parsedMessages, $"回放文件末尾不完整：最后一帧缺少 {missingBytes} 字节。");
+                    return;
+                }
+
+                try
+                {
+                    parsedMessages.Add(MessageToClient.Parser.ParseFrom(decompressedData, offset, messageLength));
+                }
+                catch (InvalidProtocolBufferException ex)
+                {
+                    throw new FormatException("回放帧数据损坏，无法解析。", ex);
+                }
+
+                offset += messageLength;
+            }
+
             messages.Clear();
+            messages.AddRange(parsedMessages);
+            if (gzipEndedEarly && parsedMessages.Count > 0)
+            {
+                IsIncompleteTail = true;
+                LoadWarning = "回放文件末尾缺少 GZip 结束标记，已加载可读取帧。";
+            }
+        }
 
-            using (var protobufStream = new CodedInputStream(decompressedData))
+        private static bool TryReadRawVarint32(byte[] data, ref int offset, out int value)
+        {
+            value = 0;
+            int shift = 0;
+            while (shift < 32)
             {
-                while (!protobufStream.IsAtEnd)
+                if (offset >= data.Length)
                 {
-                    if (messages.Count >= PlayBackConstant.MAX_MESSAGE_COUNT)
+                    return false;
+                }
+
+                byte b = data[offset++];
+                value |= (b & 0x7F) << shift;
+                if ((b & 0x80) == 0)
+                {
+                    return true;
+                }
+
+                shift += 7;
+            }
+
+            throw new FormatException("回放帧长度字段异常。");
+        }
+
+        private void AcceptOrRejectIncompleteTail(List<MessageToClient> parsedMessages, string warning)
+        {
+            if (parsedMessages.Count == 0)
+            {
+                throw new PlaybackFileIncompleteException(warning, parsedMessages.Count);
+            }
+
+            messages.Clear();
+            messages.AddRange(parsedMessages);
+            IsIncompleteTail = true;
+            LoadWarning = warning;
+        }
+
+        private static byte[] DecompressWithLimit(byte[] compressedData, out bool endedEarly)
+        {
+            endedEarly = false;
+            using (var compressedStream = new MemoryStream(compressedData))
+            using (var gzipStream = new GZipStream(compressedStream, CompressionMode.Decompress))
+            using (var decompressedStream = new MemoryStream())
+            {
+                byte[] buffer = new byte[81920];
+                while (true)
+                {
+                    int read;
+                    try
+                    {
+                        read = gzipStream.Read(buffer, 0, buffer.Length);
+                    }
+                    catch (Exception ex) when (
+                        decompressedStream.Length > 0
+                        && (ex is InvalidDataException || ex is IOException || ex is EndOfStreamException))
+                    {
+                        endedEarly = true;
+                        break;
+                    }
+
+                    if (read == 0)
                     {
-                        throw new FormatException($"Playback message count exceeds {PlayBackConstant.MAX_MESSAGE_COUNT}.");
+                        break;
                     }
 
-                    var message = new MessageToClient();
-                    protobufStream.ReadMessage(message);
-                    messages.Add(message);
+                    if (decompressedStream.Length + read > PlayBackConstant.MAX_DECOMPRESSED_PLAYBACK_BYTES)
+                    {
+                        throw new InvalidDataException($"回放解压后超过 {PlayBackConstant.MAX_DECOMPRESSED_PLAYBACK_BYTES} 字节。");
+                    }
+
+                    decompressedStream.Write(buffer, 0, read);
                 }
+
+                return decompressedStream.ToArray();
             }
         }
     }

interface/Unity/Unity-Playback/Assets/Scripts/Playback/PlayBackConstant.cs

@@ -17,6 +17,7 @@ public static class PlayBackConstant
         public const int FILE_VERSION = 9;
         public const int LEGACY_FILE_VERSION = 7;
         public const int MAX_MESSAGE_COUNT = 100000;
+        public const int MAX_DECOMPRESSED_PLAYBACK_BYTES = 256 * 1024 * 1024;
         public const string DEFAULT_PLAYBACK_PATH = "Playback/";
         public const string PLAYBACK_EXTENSION = ".thuaipb";