Fix critical stability issues from technical audit

- AccountStateManager: Add 3s execution timeout budget for replayFinalState to prevent Watchdog 0x8BADF00D terminations.
- MTWebSocketConnectionInterface: Add 5s cooldown on fallback socket redials to prevent OOMs from connection storms.
- FetchV2: Guard knownSize against shrinking on premature stream closures.
- WebProxyManager: Introduce carrierRebuildGeneration to fix race conditions during foreground resumes.
- AppDelegate: Route OS memory warnings to clear temporary Account caches to mitigate background Jetsam terminations.

Author: decoder-dev

submodules/TelegramCore/Sources/Network/FetchV2.swift

@@ -1062,16 +1062,30 @@ private final class FetchImpl {
 
             if actualLength < requestedLength {
                 let resultingSize = fetchRange.lowerBound + actualLength
-                if let currentKnownSize = self.knownSize {
-                    Logger.shared.log("FetchV2", "\(self.loggingIdentifier): setting known size to min(\(currentKnownSize), \(resultingSize)) = \(min(currentKnownSize, resultingSize))")
-                    self.knownSize = min(currentKnownSize, resultingSize)
+                let maxCompleted = state.completedRanges.ranges.last?.upperBound ?? 0
+                
+                if resultingSize < maxCompleted {
+                    Logger.shared.log("FetchV2", "\(self.loggingIdentifier): ignoring false EOF at \(resultingSize) (already fetched up to \(maxCompleted))")
                 } else {
-                    Logger.shared.log("FetchV2", "\(self.loggingIdentifier): setting known size to \(resultingSize)")
-                    self.knownSize = resultingSize
+                    if let currentKnownSize = self.knownSize {
+                        if resultingSize > 0 && resultingSize < currentKnownSize && actualLength == 0 {
+                            Logger.shared.log("FetchV2", "\(self.loggingIdentifier): ignoring 0-byte chunk as EOF because current known size is \(currentKnownSize)")
+                        } else {
+                            Logger.shared.log("FetchV2", "\(self.loggingIdentifier): setting known size to min(\(currentKnownSize), \(resultingSize)) = \(min(currentKnownSize, resultingSize))")
+                            self.knownSize = min(currentKnownSize, resultingSize)
+                        }
+                    } else {
+                        if actualLength == 0 && fetchRange.lowerBound > 0 {
+                            Logger.shared.log("FetchV2", "\(self.loggingIdentifier): ignoring 0-byte chunk as EOF for unknown size at \(fetchRange.lowerBound)")
+                        } else {
+                            Logger.shared.log("FetchV2", "\(self.loggingIdentifier): setting known size to \(resultingSize)")
+                            self.knownSize = resultingSize
+                        }
+                    }
+                    let reportedSize = self.knownSize ?? resultingSize
+                    Logger.shared.log("FetchV2", "\(self.loggingIdentifier): reporting resource size \(reportedSize)")
+                    self.onNext(.resourceSizeUpdated(reportedSize))
                 }
-                let reportedSize = self.knownSize ?? resultingSize
-                Logger.shared.log("FetchV2", "\(self.loggingIdentifier): reporting resource size \(reportedSize)")
-                self.onNext(.resourceSizeUpdated(reportedSize))
             }
 
             state.completedRanges.formUnion(RangeSet<Int64>(partRange))

submodules/TelegramCore/Sources/Network/MTWebSocketConnectionInterface.swift

@@ -182,6 +182,8 @@ final class MTWebSocketConnectionInterface: NSObject, MTTcpConnectionInterface {
         /// completes. Buffer outbound bytes until then instead of dropping them.
         private static let maximumPendingWriteBytes = 256 * 1024
 
+        private static var lastFallbackTime: Double = 0.0
+
         private enum HandshakeState {
             case tcpConnecting
             case sentUpgradeRequest
@@ -755,6 +757,16 @@ final class MTWebSocketConnectionInterface: NSObject, MTTcpConnectionInterface {
             }
 
             if let _ = self.endpointSelector.advance() {
+                let currentTime = CFAbsoluteTimeGetCurrent()
+                let timeSinceLastFallback = currentTime - Impl.lastFallbackTime
+                
+                if timeSinceLastFallback < 5.0 {
+                    Logger.shared.log("MTWebSocket", "[WS] fallback cooldown active (\(timeSinceLastFallback)s), delaying secondary endpoint probe")
+                    self.cancelWithError(error: error)
+                    return
+                }
+                Impl.lastFallbackTime = currentTime
+
                 Logger.shared.log("MTWebSocket", "[WS] trying secondary endpoint with jitter")
 
                 let delay = Double.random(in: 0.1...1.5)

submodules/TelegramCore/Sources/State/AccountStateManagementUtils.swift

@@ -3946,6 +3946,8 @@ func replayFinalState(
         }
     }
 
+    let replayStartTime = CFAbsoluteTimeGetCurrent()
+    
     var peerIdsWithAddedSecretMessages = Set<PeerId>()
 
     var updatedTypingActivities: [PeerActivitySpace: [PeerId: PeerInputActivity?]] = [:]
@@ -4177,6 +4179,11 @@ func replayFinalState(
     var isPremiumUpdated = false
 
     for operation in optimizedOperations(finalState.state.operations) {
+        if CFAbsoluteTimeGetCurrent() - replayStartTime > 3.0 {
+            Logger.shared.log("State", "replayFinalState taking too long (> 3.0s), aborting to trigger state reset")
+            return nil
+        }
+        
         switch operation {
             case let .AddMessages(messages, location):
                 if case .UpperHistoryBlock = location {

submodules/TelegramCore/Sources/State/AccountStateManager.swift

@@ -915,7 +915,8 @@ public final class AccountStateManager {
 
                                                     return (difference, replayedState, false, false)
                                                 } else {
-                                                    return (nil, nil, false, false)
+                                                    Logger.shared.log("State", "replayFinalState returned nil, triggering state reset")
+                                                    return (nil, nil, true, true)
                                                 }
                                             }
                                         }

submodules/TelegramUI/Sources/AppDelegate.swift

@@ -2124,6 +2124,7 @@ private func extractAccountManagerState(records: AccountRecordsView<TelegramAcco
             |> deliverOnMainQueue).start(next: { activeAccounts in
                 for (_, context, _) in activeAccounts.accounts {
                     context.account.postbox.clearCaches()
+                    context.account.resetCachedData()
                 }
                 Queue.mainQueue().after(1.0, {
                     let after = ForkPerformanceTelemetry.mallocHeap()

submodules/WebProxyTransport/Sources/WebProxyManager.swift

@@ -66,6 +66,7 @@ public final class WebProxyManager {
     private var lastFailureTime: Double = 0.0
     private var consecutiveFailureCount: Int = 0
     private var sidecarReadySince: Double = 0.0
+    private var carrierRebuildGeneration: UInt64 = 0
 
     /// Set from `applicationDidEnterBackground`. The WEB carrier is foreground-only.
     private var enteredBackgroundAt: Double = 0.0
@@ -356,13 +357,28 @@ public final class WebProxyManager {
     }
 
     private func performInPlaceCarrierResume(sidecar: WebProxySidecar, configuration: WebProxyConfiguration) {
+        self.startLock.lock()
+        self.carrierRebuildGeneration &+= 1
+        let generation = self.carrierRebuildGeneration
+        self.startLock.unlock()
+        
         // Rebuild the carrier behind the listener that is already published. On failure the
         // sidecar has already torn itself down, so there is nothing left to salvage and the
         // port has to change after all.
         sidecar.reconnectTransport { [weak self] result in
             guard let self else {
                 return
             }
+            
+            self.startLock.lock()
+            let isCurrent = self.carrierRebuildGeneration == generation
+            self.startLock.unlock()
+            
+            guard isCurrent else {
+                WebProxyLog.log("resume transport reconnect completed but generation is stale, ignoring")
+                return
+            }
+            
             switch result {
             case .success:
                 WebProxyLog.log("resume transport reconnect succeeded, notifying networks")