dev push

Co-authored-by: azyges <aaaaaa@aaa.aaa>
Co-authored-by: cake <admin@cakeandbanana.nl>
Reviewed-on: #134
Reviewed-by: defnotken <defnotken@noreply.git.lightless-sync.org>

LightlessSync/LightlessSync.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Authors></Authors>
     <Company></Company>
-    <Version>2.0.3</Version>
+    <Version>2.0.2.74</Version>
     <Description></Description>
     <Copyright></Copyright>
     <PackageProjectUrl>https://github.com/Light-Public-Syncshells/LightlessClient</PackageProjectUrl>

LightlessSync/PlayerData/Factories/PlayerDataFactory.cs

@@ -1,4 +1,5 @@
-using FFXIVClientStructs.FFXIV.Client.Game.Character;
+using Dalamud.Utility;
+using FFXIVClientStructs.FFXIV.Client.Game.Character;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.FileCache;
 using LightlessSync.Interop.Ipc;
@@ -11,6 +12,8 @@ using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
 
 namespace LightlessSync.PlayerData.Factories;
 
@@ -124,6 +127,9 @@ public class PlayerDataFactory
         if (playerPointer == IntPtr.Zero)
             return true;
 
+        if (!IsPointerValid(playerPointer))
+            return true;
+
         var character = (Character*)playerPointer;
         if (character == null)
             return true;
@@ -132,9 +138,28 @@ public class PlayerDataFactory
         if (gameObject == null)
             return true;
 
+        if (!IsPointerValid((IntPtr)gameObject))
+            return true;
+
         return gameObject->DrawObject == null;
     }
 
+    private static bool IsPointerValid(IntPtr ptr)
+    {
+        if (ptr == IntPtr.Zero)
+            return false;
+
+        try
+        {
+            _ = Marshal.ReadByte(ptr);
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     private static bool IsCacheFresh(CacheEntry entry)
         => (DateTime.UtcNow - entry.CreatedUtc) <= _characterCacheTtl;
 
@@ -169,11 +194,6 @@ public class PlayerDataFactory
             using var cts = new CancellationTokenSource(_hardBuildTimeout);
             var fragment = await CreateCharacterDataInternal(obj, cts.Token).ConfigureAwait(false);
 
-        fragment.FileReplacements =
-                new HashSet<FileReplacement>(resolvedPaths.Select(c => new FileReplacement([.. c.Value], c.Key)), FileReplacementComparer.Instance)
-                .Where(p => p.HasFileReplacement).ToHashSet();
-        var allowedExtensions = CacheMonitor.AllowedFileExtensions;
-        fragment.FileReplacements.RemoveWhere(c => c.GamePaths.Any(g => !allowedExtensions.Any(e => g.EndsWith(e, StringComparison.OrdinalIgnoreCase))));
             _characterBuildCache[key] = new CacheEntry(fragment, DateTime.UtcNow);
             PruneCharacterCacheIfNeeded();
 
@@ -219,10 +239,6 @@ public class PlayerDataFactory
             .ConfigureAwait(false);
 
         // get all remaining paths and resolve them
-        var transientPaths = ManageSemiTransientData(objectKind);
-        var resolvedTransientPaths = transientPaths.Count == 0
-            ? new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase).AsReadOnly()
-            : await GetFileReplacementsFromPaths(playerRelatedObject, transientPaths, new HashSet<string>(StringComparer.Ordinal)).ConfigureAwait(false);
         ct.ThrowIfCancellationRequested();
 
         if (await CheckForNullDrawObject(playerRelatedObject.Address).ConfigureAwait(false))
@@ -540,13 +556,31 @@ public class PlayerDataFactory
 
             var hash = g.Key;
 
+            var resolvedPath = g.Select(f => f.ResolvedPath).Distinct(StringComparer.OrdinalIgnoreCase);
+            var papPathSummary = string.Join(", ", resolvedPath);
+            if (papPathSummary.IsNullOrEmpty())
+                papPathSummary = "<unknown pap path>";
+
             Dictionary<string, List<ushort>>? papIndices = null;
 
             await _papParseLimiter.WaitAsync(ct).ConfigureAwait(false);
             try
             {
-                papIndices = await Task.Run(() => _modelAnalyzer.GetBoneIndicesFromPap(hash), ct)
+                try
-                    .ConfigureAwait(false);
+                {
+                    papIndices = await Task.Run(() => _modelAnalyzer.GetBoneIndicesFromPap(hash, persistToConfig: false), ct)
+                        .ConfigureAwait(false);
+                }
+                catch (SEHException ex)
+                {
+                    _logger.LogError(ex, "SEH exception while parsing PAP file (hash={hash}, path={path}). Error code: 0x{code:X}. Skipping this animation.", hash, papPathSummary, ex.ErrorCode);
+                    continue;
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Unexpected error parsing PAP file (hash={hash}, path={path}). Skipping this animation.", hash, papPathSummary);
+                    continue;
+                }
             }
             finally
             {
@@ -556,43 +590,75 @@ public class PlayerDataFactory
             if (papIndices == null || papIndices.Count == 0)
                 continue;
 
-            if (papIndices.All(k => k.Value.DefaultIfEmpty().Max() <= 105))
+            bool hasValidIndices = false;
+            try
+            {
+                hasValidIndices = papIndices.All(k => k.Value != null && k.Value.DefaultIfEmpty().Max() <= 105);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Error validating bone indices for PAP (hash={hash}, path={path}). Skipping.", hash, papPathSummary);
+                continue;
+            }
+
+            if (hasValidIndices)
                 continue;
 
             if (_logger.IsEnabled(LogLevel.Debug))
             {
-                var papBuckets = papIndices
+                try
-                    .Select(kvp => new
+                {
-                    {
+                    var papBuckets = papIndices
-                        Raw = kvp.Key,
+                        .Where(kvp => kvp.Value is { Count: > 0 })
-                        Key = XivDataAnalyzer.CanonicalizeSkeletonKey(kvp.Key),
+                        .Select(kvp => new
-                        Indices = kvp.Value
+                        {
-                    })
+                            Raw = kvp.Key,
-                    .Where(x => x.Indices is { Count: > 0 })
+                            Key = XivDataAnalyzer.CanonicalizeSkeletonKey(kvp.Key),
-                    .GroupBy(x => string.IsNullOrEmpty(x.Key) ? x.Raw : x.Key!, StringComparer.OrdinalIgnoreCase)
+                            Indices = kvp.Value
-                    .Select(grp =>
+                        })
-                    {
+                        .Where(x => x.Indices is { Count: > 0 })
-                        var all = grp.SelectMany(v => v.Indices).ToList();
+                        .GroupBy(x => string.IsNullOrEmpty(x.Key) ? x.Raw : x.Key!, StringComparer.OrdinalIgnoreCase)
-                        var min = all.Count > 0 ? all.Min() : 0;
+                        .Select(grp =>
-                        var max = all.Count > 0 ? all.Max() : 0;
+                        {
-                        var raws = string.Join(',', grp.Select(v => v.Raw).Distinct(StringComparer.OrdinalIgnoreCase));
+                            var all = grp.SelectMany(v => v.Indices).ToList();
-                        return $"{grp.Key}(min={min},max={max},raw=[{raws}])";
+                            var min = all.Count > 0 ? all.Min() : 0;
-                    })
+                            var max = all.Count > 0 ? all.Max() : 0;
-                    .ToList();
+                            var raws = string.Join(',', grp.Select(v => v.Raw).Distinct(StringComparer.OrdinalIgnoreCase));
+                            return $"{grp.Key}(min={min},max={max},raw=[{raws}])";
+                        })
+                        .ToList();
 
-                _logger.LogDebug("SEND pap buckets for hash={hash}: {b}",
+                    _logger.LogDebug("SEND pap buckets for hash={hash}: {b}",
-                    hash,
+                        hash,
-                    string.Join(" | ", papBuckets));
+                        string.Join(" | ", papBuckets));
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogDebug(ex, "Error logging PAP bucket details for hash={hash}", hash);
+                }
             }
 
-            if (XivDataAnalyzer.IsPapCompatible(localBoneSets, papIndices, mode, allowBasedShift, allownNightIndex, out var reason))
+            bool isCompatible = false;
+            string reason = string.Empty;
+            try
+            {
+                isCompatible = XivDataAnalyzer.IsPapCompatible(localBoneSets, papIndices, mode, allowBasedShift, allownNightIndex, out reason);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Error checking PAP compatibility for hash={hash}, path={path}. Treating as incompatible.", hash, papPathSummary);
+                reason = $"Exception during compatibility check: {ex.Message}";
+                isCompatible = false;
+            }
+
+            if (isCompatible)
                 continue;
 
             noValidationFailed++;
 
             _logger.LogWarning(
-                "Animation PAP hash {hash} is not compatible with local skeletons; dropping all mappings for this hash. Reason: {reason}",
+                "Animation PAP is not compatible with local skeletons; dropping mappings for {papPath}. Reason: {reason}",
-                hash,
+                papPathSummary,
                 reason);
 
             var removedGamePaths = fragment.FileReplacements
@@ -672,7 +738,7 @@ public class PlayerDataFactory
                         list.Add(forwardPaths[i].ToLowerInvariant());
                     else
                     {
-                        resolvedPaths[filePath] = [forwardPaths[i].ToLowerInvariant()];
+                        resolvedPaths[filePath] = [forwardPathsLower[i]];
                     }
                 }
 

LightlessSync/PlayerData/Handlers/GameObjectHandler.cs

@@ -113,16 +113,16 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
     public async Task ActOnFrameworkAfterEnsureNoDrawAsync(Action<Dalamud.Game.ClientState.Objects.Types.ICharacter> act, CancellationToken token)
     {
         while (await _dalamudUtil.RunOnFrameworkThread(() =>
-               {
+        {
-                   EnsureLatestObjectState();
+            EnsureLatestObjectState();
-                   if (CurrentDrawCondition != DrawCondition.None) return true;
+            if (CurrentDrawCondition != DrawCondition.None) return true;
-                   var gameObj = _dalamudUtil.CreateGameObject(Address);
+            var gameObj = _dalamudUtil.CreateGameObject(Address);
-                   if (gameObj is Dalamud.Game.ClientState.Objects.Types.ICharacter chara)
+            if (gameObj is Dalamud.Game.ClientState.Objects.Types.ICharacter chara)
-                   {
+            {
-                       act.Invoke(chara);
+                act.Invoke(chara);
-                   }
+            }
-                   return false;
+            return false;
-               }).ConfigureAwait(false))
+        }).ConfigureAwait(false))
         {
             await Task.Delay(250, token).ConfigureAwait(false);
         }
@@ -169,37 +169,36 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
         return $"{owned}/{ObjectKind}:{Name} ({Address:X},{DrawObjectAddress:X})";
     }
 
-    protected override void Dispose(bool disposing)
+    private void CheckAndUpdateObject() => CheckAndUpdateObject(allowPublish: true);
-    {
-        base.Dispose(disposing);
 
-        Mediator.Publish(new GameObjectHandlerDestroyedMessage(this, _isOwnedObject));
+    private unsafe void CheckAndUpdateObject(bool allowPublish)
-    }
-
-    private unsafe void CheckAndUpdateObject()
     {
         var prevAddr = Address;
         var prevDrawObj = DrawObjectAddress;
+        string? nameString = null;
 
         Address = _getAddress();
+
         if (Address != IntPtr.Zero)
         {
             var gameObject = (FFXIVClientStructs.FFXIV.Client.Game.Object.GameObject*)Address;
-            var drawObjAddr = (IntPtr)gameObject->DrawObject;
+            DrawObjectAddress = (IntPtr)gameObject->DrawObject;
-            DrawObjectAddress = drawObjAddr;
             EntityId = gameObject->EntityId;
-            CurrentDrawCondition = DrawCondition.None;
+
+            var chara = (Character*)Address;
+            nameString = chara->GameObject.NameString;
+            if (!string.IsNullOrEmpty(nameString) && !string.Equals(nameString, Name, StringComparison.Ordinal))
+                Name = nameString;
         }
         else
         {
             DrawObjectAddress = IntPtr.Zero;
             EntityId = uint.MaxValue;
-            CurrentDrawCondition = DrawCondition.DrawObjectZero;
         }
 
         CurrentDrawCondition = IsBeingDrawnUnsafe();
 
-        if (_haltProcessing) return;
+        if (_haltProcessing || !allowPublish) return;
 
         bool drawObjDiff = DrawObjectAddress != prevDrawObj;
         bool addrDiff = Address != prevAddr;
@@ -207,16 +206,18 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
         if (Address != IntPtr.Zero && DrawObjectAddress != IntPtr.Zero)
         {
             var chara = (Character*)Address;
-            var name = chara->GameObject.NameString;
+            var drawObj = (DrawObject*)DrawObjectAddress;
-            bool nameChange = !string.Equals(name, Name, StringComparison.Ordinal);
+            var objType = drawObj->Object.GetObjectType();
-            if (nameChange)
+            var isHuman = objType == ObjectType.CharacterBase
-            {
+                          && ((CharacterBase*)drawObj)->GetModelType() == CharacterBase.ModelType.Human;
-                Name = name;
+
-            }
+            nameString ??= ((Character*)Address)->GameObject.NameString;
+            var nameChange = !string.Equals(nameString, Name, StringComparison.Ordinal);
+            if (nameChange) Name = nameString;
+
             bool equipDiff = false;
 
-            if (((DrawObject*)DrawObjectAddress)->Object.GetObjectType() == ObjectType.CharacterBase
+            if (isHuman)
-                && ((CharacterBase*)DrawObjectAddress)->GetModelType() == CharacterBase.ModelType.Human)
             {
                 var classJob = chara->CharacterData.ClassJob;
                 if (classJob != _classJob)
@@ -226,7 +227,7 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
                     Mediator.Publish(new ClassJobChangedMessage(this));
                 }
 
-                equipDiff = CompareAndUpdateEquipByteData((byte*)&((Human*)DrawObjectAddress)->Head);
+                equipDiff = CompareAndUpdateEquipByteData((byte*)&((Human*)drawObj)->Head);
 
                 ref var mh = ref chara->DrawData.Weapon(WeaponSlot.MainHand);
                 ref var oh = ref chara->DrawData.Weapon(WeaponSlot.OffHand);
@@ -251,12 +252,11 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
 
             bool customizeDiff = false;
 
-            if (((DrawObject*)DrawObjectAddress)->Object.GetObjectType() == ObjectType.CharacterBase
+            if (isHuman)
-                && ((CharacterBase*)DrawObjectAddress)->GetModelType() == CharacterBase.ModelType.Human)
             {
-                var gender = ((Human*)DrawObjectAddress)->Customize.Sex;
+                var gender = ((Human*)drawObj)->Customize.Sex;
-                var raceId = ((Human*)DrawObjectAddress)->Customize.Race;
+                var raceId = ((Human*)drawObj)->Customize.Race;
-                var tribeId = ((Human*)DrawObjectAddress)->Customize.Tribe;
+                var tribeId = ((Human*)drawObj)->Customize.Tribe;
 
                 if (_isOwnedObject && ObjectKind == ObjectKind.Player
                     && (gender != Gender || raceId != RaceId || tribeId != TribeId))
@@ -267,7 +267,7 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
                     TribeId = tribeId;
                 }
 
-                customizeDiff = CompareAndUpdateCustomizeData(((Human*)DrawObjectAddress)->Customize.Data);
+                customizeDiff = CompareAndUpdateCustomizeData(((Human*)drawObj)->Customize.Data);
                 if (customizeDiff)
                     Logger.LogTrace("Checking [{this}] customize data as human from draw obj, result: {diff}", this, customizeDiff);
             }
@@ -356,12 +356,10 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
 
     private void FrameworkUpdate()
     {
-        if (!_delayedZoningTask?.IsCompleted ?? false) return;
-
         try
         {
-            _performanceCollector.LogPerformance(this, $"CheckAndUpdateObject>{(_isOwnedObject ? "Self" : "Other")}+{ObjectKind}/{(string.IsNullOrEmpty(Name) ? "Unk" : Name)}"
+            var zoningDelayActive = !(_delayedZoningTask?.IsCompleted ?? true);
-                + $"+{Address.ToString("X")}", CheckAndUpdateObject);
+            _performanceCollector.LogPerformance(this, $"CheckAndUpdateObject>{(_isOwnedObject ? "Self" : "Other")}+{ObjectKind}/{(string.IsNullOrEmpty(Name) ? "Unk" : Name)}", () => CheckAndUpdateObject(allowPublish: !zoningDelayActive));
         }
         catch (Exception ex)
         {
@@ -462,6 +460,6 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
                 Logger.LogDebug("[{this}] Delay after zoning complete", this);
                 _zoningCts.Dispose();
             }
-        });
+        }, _zoningCts.Token);
     }
 }

LightlessSync/PlayerData/Pairs/PairHandlerAdapter.cs

@@ -25,7 +25,6 @@ using Microsoft.Extensions.Logging;
 using DalamudObjectKind = Dalamud.Game.ClientState.Objects.Enums.ObjectKind;
 using ObjectKind = LightlessSync.API.Data.Enum.ObjectKind;
 using FileReplacementDataComparer = LightlessSync.PlayerData.Data.FileReplacementDataComparer;
-using LightlessSync.LightlessConfiguration;
 
 namespace LightlessSync.PlayerData.Pairs;
 
@@ -96,6 +95,9 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     private readonly Dictionary<ObjectKind, HashSet<PlayerChanges>> _pendingOwnedChanges = new();
     private CancellationTokenSource? _ownedRetryCts;
     private Task _ownedRetryTask = Task.CompletedTask;
+
+
+
     private static readonly TimeSpan OwnedRetryInitialDelay = TimeSpan.FromSeconds(1);
     private static readonly TimeSpan OwnedRetryMaxDelay = TimeSpan.FromSeconds(10);
     private static readonly TimeSpan OwnedRetryStaleDataGrace = TimeSpan.FromMinutes(5);
@@ -109,6 +111,9 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     };
 
     private readonly ConcurrentDictionary<string, byte> _blockedPapHashes = new(StringComparer.OrdinalIgnoreCase);
+    private AnimationValidationMode _lastAnimMode = (AnimationValidationMode)(-1);
+    private bool _lastAllowOneBasedShift;
+    private bool _lastAllowNeighborTolerance;
     private readonly ConcurrentDictionary<string, byte> _dumpedRemoteSkeletonForHash = new(StringComparer.OrdinalIgnoreCase);
 
     private DateTime? _invisibleSinceUtc;
@@ -2455,6 +2460,8 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
 
         try
         {
+            RefreshPapBlockCacheIfAnimSettingsChanged();
+
             var replacementList = charaData.FileReplacements.SelectMany(k => k.Value.Where(v => string.IsNullOrEmpty(v.FileSwapPath))).ToList();
             Parallel.ForEach(replacementList, new ParallelOptions()
             {
@@ -2855,6 +2862,26 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
     }
 
+    private void RefreshPapBlockCacheIfAnimSettingsChanged()
+    {
+        var cfg = _configService.Current;
+
+        if (cfg.AnimationValidationMode != _lastAnimMode
+            || cfg.AnimationAllowOneBasedShift != _lastAllowOneBasedShift
+            || cfg.AnimationAllowNeighborIndexTolerance != _lastAllowNeighborTolerance)
+        {
+            _lastAnimMode = cfg.AnimationValidationMode;
+            _lastAllowOneBasedShift = cfg.AnimationAllowOneBasedShift;
+            _lastAllowNeighborTolerance = cfg.AnimationAllowNeighborIndexTolerance;
+
+            _blockedPapHashes.Clear();
+            _dumpedRemoteSkeletonForHash.Clear();
+
+            Logger.LogDebug("{handler}: Cleared blocked PAP cache due to animation setting change (mode={mode}, shift={shift}, neigh={neigh})",
+                GetLogIdentifier(), _lastAnimMode, _lastAllowOneBasedShift, _lastAllowNeighborTolerance);
+        }
+    }
+
     private static void SplitPapMappings(
         Dictionary<(string GamePath, string? Hash), string> moddedPaths,
         out Dictionary<(string GamePath, string? Hash), string> withoutPap,
@@ -2879,6 +2906,8 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         Dictionary<(string GamePath, string? Hash), string> papOnly,
         CancellationToken token)
     {
+        RefreshPapBlockCacheIfAnimSettingsChanged();
+
         var mode = _configService.Current.AnimationValidationMode;
         var allowBasedShift = _configService.Current.AnimationAllowOneBasedShift;
         var allownNightIndex = _configService.Current.AnimationAllowNeighborIndexTolerance;

LightlessSync/Plugin.cs

@@ -123,7 +123,6 @@ public sealed class Plugin : IDalamudPlugin
         services.AddSingleton<HubFactory>();
         services.AddSingleton<FileUploadManager>();
         services.AddSingleton<FileTransferOrchestrator>();
-        services.AddSingleton<FileDownloadDeduplicator>();
         services.AddSingleton<LightlessPlugin>();
         services.AddSingleton<LightlessProfileManager>();
         services.AddSingleton<TextureCompressionService>();

LightlessSync/Services/DalamudUtilService.cs

@@ -705,7 +705,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
         if (location.ServerId is 0 || location.TerritoryId is 0) return String.Empty;
         var str = WorldData.Value[(ushort)location.ServerId];
 
-        if (ContentFinderData.Value.TryGetValue(location.TerritoryId , out var dutyName))
+        if (ContentFinderData.Value.TryGetValue(location.TerritoryId, out var dutyName))
         {
             str += $" - [In Duty]{dutyName}";
         }
@@ -881,7 +881,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
         {
             // ignore
         }
-        catch (AccessViolationException ex)
+        catch (Exception ex)
         {
             logger.LogWarning(ex, "Error accessing {handler}, object does not exist anymore?", handler);
         }
@@ -953,37 +953,87 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
         });
     }
 
+    [DllImport("kernel32.dll", SetLastError = true)]
+    private static extern bool IsBadReadPtr(IntPtr ptr, UIntPtr size);
+
+    private static bool IsValidPointer(nint ptr, int size = 8)
+    {
+        if (ptr == nint.Zero)
+            return false;
+
+        try
+        {
+            if (!Util.IsWine())
+            {
+                return !IsBadReadPtr(ptr, (UIntPtr)size);
+            }
+            return ptr != nint.Zero && (ptr % IntPtr.Size) == 0;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
     private unsafe void CheckCharacterForDrawing(nint address, string characterName)
     {
+        if (address == nint.Zero)
+            return;
+
+        if (!IsValidPointer(address))
+        {
+            _logger.LogDebug("Invalid pointer for character {name} at {addr}", characterName, address.ToString("X"));
+            return;
+        }
+
         var gameObj = (GameObject*)address;
+
+        if (gameObj == null)
+            return;
+
+        if (!_objectTable.Any(o => o?.Address == address))
+        {
+            _logger.LogDebug("Character {name} at {addr} no longer in object table", characterName, address.ToString("X"));
+            return;
+        }
+
+        if (gameObj->ObjectKind == 0)
+            return;
+
         var drawObj = gameObj->DrawObject;
         bool isDrawing = false;
         bool isDrawingChanged = false;
-        if ((nint)drawObj != IntPtr.Zero)
+
+        if ((nint)drawObj != IntPtr.Zero && IsValidPointer((nint)drawObj))
         {
             isDrawing = gameObj->RenderFlags == (VisibilityFlags)0b100000000000;
+
             if (!isDrawing)
             {
-                isDrawing = ((CharacterBase*)drawObj)->HasModelInSlotLoaded != 0;
+                var charBase = (CharacterBase*)drawObj;
-                if (!isDrawing)
+                if (charBase != null && IsValidPointer((nint)charBase))
                 {
-                    isDrawing = ((CharacterBase*)drawObj)->HasModelFilesInSlotLoaded != 0;
+                    isDrawing = charBase->HasModelInSlotLoaded != 0;
-                    if (isDrawing && !string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
+                    if (!isDrawing)
-                        && !string.Equals(_lastGlobalBlockReason, "HasModelFilesInSlotLoaded", StringComparison.Ordinal))
                     {
-                        _lastGlobalBlockPlayer = characterName;
+                        isDrawing = charBase->HasModelFilesInSlotLoaded != 0;
-                        _lastGlobalBlockReason = "HasModelFilesInSlotLoaded";
+                        if (isDrawing && !string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
-                        isDrawingChanged = true;
+                            && !string.Equals(_lastGlobalBlockReason, "HasModelFilesInSlotLoaded", StringComparison.Ordinal))
+                        {
+                            _lastGlobalBlockPlayer = characterName;
+                            _lastGlobalBlockReason = "HasModelFilesInSlotLoaded";
+                            isDrawingChanged = true;
+                        }
                     }
-                }
+                    else
-                else
-                {
-                    if (!string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
-                        && !string.Equals(_lastGlobalBlockReason, "HasModelInSlotLoaded", StringComparison.Ordinal))
                     {
-                        _lastGlobalBlockPlayer = characterName;
+                        if (!string.Equals(_lastGlobalBlockPlayer, characterName, StringComparison.Ordinal)
-                        _lastGlobalBlockReason = "HasModelInSlotLoaded";
+                            && !string.Equals(_lastGlobalBlockReason, "HasModelInSlotLoaded", StringComparison.Ordinal))
-                        isDrawingChanged = true;
+                        {
+                            _lastGlobalBlockPlayer = characterName;
+                            _lastGlobalBlockReason = "HasModelInSlotLoaded";
+                            isDrawingChanged = true;
+                        }
                     }
                 }
             }
@@ -1014,6 +1064,11 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
 
     private unsafe void FrameworkOnUpdateInternal()
     {
+        if (!_clientState.IsLoggedIn || _objectTable.LocalPlayer == null)
+        {
+            return;
+        }
+
         if ((_objectTable.LocalPlayer?.IsDead ?? false) && _condition[ConditionFlag.BoundByDuty])
         {
             return;
@@ -1033,12 +1088,17 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
                     }
 
                     var playerDescriptors = _actorObjectService.PlayerDescriptors;
-                    for (var i = 0; i < playerDescriptors.Count; i++)
+                    var descriptorCount = playerDescriptors.Count;
+
+                    for (var i = 0; i < descriptorCount; i++)
                     {
+                        if (i >= playerDescriptors.Count)
+                            break;
+
                         var actor = playerDescriptors[i];
 
                         var playerAddress = actor.Address;
-                        if (playerAddress == nint.Zero)
+                        if (playerAddress == nint.Zero || !IsValidPointer(playerAddress))
                             continue;
 
                         if (actor.ObjectIndex >= 200)
@@ -1052,17 +1112,16 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
 
                         if (!IsAnythingDrawing)
                         {
-                            var gameObj = (GameObject*)playerAddress;
+                            if (!_objectTable.Any(o => o?.Address == playerAddress))
-                            var currentName = gameObj != null ? gameObj->NameString ?? string.Empty : string.Empty;
+                            {
-                            var charaName = string.IsNullOrEmpty(currentName) ? actor.Name : currentName;
+                                continue;
-                            CheckCharacterForDrawing(playerAddress, charaName);
+                            }
+
+                            CheckCharacterForDrawing(playerAddress, actor.Name);
+
                             if (IsAnythingDrawing)
                                 break;
                         }
-                        else
-                        {
-                            break;
-                        }
                     }
                 });
 
@@ -1131,7 +1190,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
                 });
 
             // Cutscene
-            HandleStateTransition(() => IsInCutscene,v => IsInCutscene = v, shouldBeInCutscene, "Cutscene",
+            HandleStateTransition(() => IsInCutscene, v => IsInCutscene = v, shouldBeInCutscene, "Cutscene",
                 onEnter: () =>
                 {
                     Mediator.Publish(new CutsceneStartMessage());

LightlessSync/Services/XivDataAnalyzer.cs

@@ -1,5 +1,6 @@
 using FFXIVClientStructs.FFXIV.Client.Game.Character;
 using FFXIVClientStructs.FFXIV.Client.Graphics.Scene;
+using FFXIVClientStructs.Havok.Common.Serialize.Resource;
 using FFXIVClientStructs.Havok.Animation;
 using FFXIVClientStructs.Havok.Common.Base.Types;
 using FFXIVClientStructs.Havok.Common.Serialize.Util;
@@ -145,156 +146,297 @@ public sealed partial class XivDataAnalyzer
         using var reader = new BinaryReader(fs);
 
         // PAP header (mostly from vfxeditor)
-        _ = reader.ReadInt32(); // ignore
-        _ = reader.ReadInt32(); // ignore
-        _ = reader.ReadInt16(); // num animations
-        _ = reader.ReadInt16(); // modelid
-
-        var type = reader.ReadByte(); // type
-        if (type != 0)
-            return null; // not human
-
-        _ = reader.ReadByte();  // variant
-        _ = reader.ReadInt32(); // ignore
-
-        var havokPosition = reader.ReadInt32();
-        var footerPosition = reader.ReadInt32();
-
-        // sanity checks
-        if (havokPosition <= 0 || footerPosition <= havokPosition || footerPosition > fs.Length)
-            return null;
-
-        var havokDataSizeLong = (long)footerPosition - havokPosition;
-        if (havokDataSizeLong <= 8 || havokDataSizeLong > int.MaxValue)
-            return null;
-
-        var havokDataSize = (int)havokDataSizeLong;
-
-        reader.BaseStream.Position = havokPosition;
-        var havokData = reader.ReadBytes(havokDataSize);
-        if (havokData.Length <= 8)
-            return null;
-
-        var tempSets = new Dictionary<string, HashSet<ushort>>(StringComparer.OrdinalIgnoreCase);
-
-        var tempHavokDataPath = Path.Combine(Path.GetTempPath(), $"lightless_{Guid.NewGuid():N}.hkx");
-        IntPtr tempHavokDataPathAnsi = IntPtr.Zero;
-
         try
         {
-            File.WriteAllBytes(tempHavokDataPath, havokData);
+            _ = reader.ReadInt32(); // ignore
+            _ = reader.ReadInt32(); // ignore
+            var numAnimations = reader.ReadInt16(); // num animations
+            var modelId = reader.ReadInt16(); // modelid
 
-            if (!File.Exists(tempHavokDataPath))
+            if (numAnimations < 0 || numAnimations > 1000)
             {
-                _logger.LogTrace("Temporary havok file did not exist when attempting to load: {path}", tempHavokDataPath);
+                _logger.LogWarning("PAP file {hash} has invalid animation count {count}, skipping", hash, numAnimations);
                 return null;
             }
 
-            tempHavokDataPathAnsi = Marshal.StringToHGlobalAnsi(tempHavokDataPath);
+            var type = reader.ReadByte(); // type
+            if (type != 0)
+                return null; // not human
 
-            var loadoptions = stackalloc hkSerializeUtil.LoadOptions[1];
+            _ = reader.ReadByte();  // variant
-            loadoptions->TypeInfoRegistry = hkBuiltinTypeRegistry.Instance()->GetTypeInfoRegistry();
+            _ = reader.ReadInt32(); // ignore
-            loadoptions->ClassNameRegistry = hkBuiltinTypeRegistry.Instance()->GetClassNameRegistry();
-            loadoptions->Flags = new hkFlags<hkSerializeUtil.LoadOptionBits, int>
-            {
-                Storage = (int)hkSerializeUtil.LoadOptionBits.Default
-            };
 
-            var resource = hkSerializeUtil.LoadFromFile((byte*)tempHavokDataPathAnsi, null, loadoptions);
+            var havokPosition = reader.ReadInt32();
-            if (resource == null)
+            var footerPosition = reader.ReadInt32();
+
+            if (havokPosition <= 0 || footerPosition <= havokPosition ||
+                footerPosition > fs.Length || havokPosition >= fs.Length)
             {
-                _logger.LogWarning("Havok resource was null after loading from {path}", tempHavokDataPath);
+                _logger.LogWarning("PAP file {hash} has invalid offsets (havok={havok}, footer={footer}, length={length})",
+                    hash, havokPosition, footerPosition, fs.Length);
                 return null;
             }
 
-            var rootLevelName = @"hkRootLevelContainer"u8;
+            var havokDataSizeLong = (long)footerPosition - havokPosition;
-            fixed (byte* n1 = rootLevelName)
+            if (havokDataSizeLong <= 8 || havokDataSizeLong > int.MaxValue) 
             {
-                var container = (hkRootLevelContainer*)resource->GetContentsPointer(n1, hkBuiltinTypeRegistry.Instance()->GetTypeInfoRegistry());
+                _logger.LogWarning("PAP file {hash} has invalid Havok data size {size}", hash, havokDataSizeLong);
-                if (container == null)
+                return null;
-                    return null;
+            }
 
-                var animationName = @"hkaAnimationContainer"u8;
+            var havokDataSize = (int)havokDataSizeLong;
-                fixed (byte* n2 = animationName)
+
+            reader.BaseStream.Position = havokPosition;
+
+            var havokData = new byte[havokDataSize];
+            var bytesRead = reader.Read(havokData, 0, havokDataSize);
+            if (bytesRead != havokDataSize)
+            {
+                _logger.LogWarning("PAP file {hash}: Expected to read {expected} bytes but got {actual}",
+                    hash, havokDataSize, bytesRead);
+                return null;
+            }
+
+            if (havokData.Length < 8)
+                return null;
+
+            var tempSets = new Dictionary<string, HashSet<ushort>>(StringComparer.OrdinalIgnoreCase);
+
+            var tempFileName = $"lightless_pap_{Guid.NewGuid():N}_{hash.Substring(0, Math.Min(8, hash.Length))}.hkx";
+            var tempHavokDataPath = Path.Combine(Path.GetTempPath(), tempFileName);
+            IntPtr tempHavokDataPathAnsi = IntPtr.Zero;
+
+            try
+            {
+                var tempDir = Path.GetDirectoryName(tempHavokDataPath);
+                if (!Directory.Exists(tempDir))
                 {
-                    var animContainer = (hkaAnimationContainer*)container->findObjectByName(n2, null);
+                    _logger.LogWarning("Temp directory {dir} doesn't exist", tempDir);
-                    if (animContainer == null)
+                    return null;
-                        return null;
+                }
 
-                    for (int i = 0; i < animContainer->Bindings.Length; i++)
+                File.WriteAllBytes(tempHavokDataPath, havokData);
+
+                if (!File.Exists(tempHavokDataPath))
+                {
+                    _logger.LogWarning("Temporary havok file was not created at {path}", tempHavokDataPath);
+                    return null;
+                }
+
+                var writtenFileInfo = new FileInfo(tempHavokDataPath);
+                if (writtenFileInfo.Length != havokData.Length)
+                {
+                    _logger.LogWarning("Written temp file size mismatch: expected {expected}, got {actual}",
+                        havokData.Length, writtenFileInfo.Length);
+                    File.Delete(tempHavokDataPath);
+                    return null;
+                }
+
+                tempHavokDataPathAnsi = Marshal.StringToHGlobalAnsi(tempHavokDataPath);
+
+                var loadoptions = stackalloc hkSerializeUtil.LoadOptions[1];
+                loadoptions->TypeInfoRegistry = hkBuiltinTypeRegistry.Instance()->GetTypeInfoRegistry();
+                loadoptions->ClassNameRegistry = hkBuiltinTypeRegistry.Instance()->GetClassNameRegistry();
+                loadoptions->Flags = new hkFlags<hkSerializeUtil.LoadOptionBits, int>
+                {
+                    Storage = (int)hkSerializeUtil.LoadOptionBits.Default
+                };
+
+                hkResource* resource = null;
+                try
+                {
+                    resource = hkSerializeUtil.LoadFromFile((byte*)tempHavokDataPathAnsi, null, loadoptions);
+                }
+                catch (SEHException ex)
+                {
+                    _logger.LogError(ex, "SEH exception loading Havok file from {path} (hash={hash}). Native error code: 0x{code:X}",
+                        tempHavokDataPath, hash, ex.ErrorCode);
+                    return null;
+                }
+
+                if (resource == null)
+                {
+                    _logger.LogDebug("Havok resource was null after loading from {path} (hash={hash})", tempHavokDataPath, hash);
+                    return null;
+                }
+
+                if ((nint)resource == nint.Zero || !IsValidPointer((IntPtr)resource))
+                {
+                    _logger.LogDebug("Havok resource pointer is invalid (hash={hash})", hash);
+                    return null;
+                }
+
+                var rootLevelName = @"hkRootLevelContainer"u8;
+                fixed (byte* n1 = rootLevelName)
+                {
+                    var container = (hkRootLevelContainer*)resource->GetContentsPointer(n1, hkBuiltinTypeRegistry.Instance()->GetTypeInfoRegistry());
+                    if (container == null)
                     {
-                        var binding = animContainer->Bindings[i].ptr;
+                        _logger.LogDebug("hkRootLevelContainer is null (hash={hash})", hash);
-                        if (binding == null)
+                        return null;
-                            continue;
+                    }
 
-                        var rawSkel = binding->OriginalSkeletonName.String;
+                    if ((nint)container == nint.Zero || !IsValidPointer((IntPtr)container))
-                        var skeletonKey = CanonicalizeSkeletonKey(rawSkel);
+                    {
-                        if (string.IsNullOrEmpty(skeletonKey))
+                        _logger.LogDebug("hkRootLevelContainer pointer is invalid (hash={hash})", hash);
-                            continue;
+                        return null;
+                    }
 
-                        var boneTransform = binding->TransformTrackToBoneIndices;
+                    var animationName = @"hkaAnimationContainer"u8;
-                        if (boneTransform.Length <= 0)
+                    fixed (byte* n2 = animationName)
-                            continue;
+                    {
-
+                        var animContainer = (hkaAnimationContainer*)container->findObjectByName(n2, null);
-                        if (!tempSets.TryGetValue(skeletonKey, out var set))
+                        if (animContainer == null)
                         {
-                            set = [];
+                            _logger.LogDebug("hkaAnimationContainer is null (hash={hash})", hash);
-                            tempSets[skeletonKey] = set;
+                            return null;
                         }
 
-                        for (int boneIdx = 0; boneIdx < boneTransform.Length; boneIdx++)
+                        if ((nint)animContainer == nint.Zero || !IsValidPointer((IntPtr)animContainer))
                         {
-                            var v = boneTransform[boneIdx];
+                            _logger.LogDebug("hkaAnimationContainer pointer is invalid (hash={hash})", hash);
-                            if (v < 0) continue;
+                            return null;
-                            set.Add((ushort)v);
+                        }
+
+                        if (animContainer->Bindings.Length < 0 || animContainer->Bindings.Length > 10000)
+                        {
+                            _logger.LogDebug("Invalid bindings count {count} (hash={hash})", animContainer->Bindings.Length, hash);
+                            return null;
+                        }
+
+                        for (int i = 0; i < animContainer->Bindings.Length; i++)
+                        {
+                            var binding = animContainer->Bindings[i].ptr;
+                            if (binding == null)
+                                continue;
+
+                            if ((nint)binding == nint.Zero || !IsValidPointer((IntPtr)binding))
+                            {
+                                _logger.LogDebug("Skipping invalid binding at index {index} (hash={hash})", i, hash);
+                                continue;
+                            }
+
+                            var rawSkel = binding->OriginalSkeletonName.String;
+                            var skeletonKey = CanonicalizeSkeletonKey(rawSkel);
+                            if (string.IsNullOrEmpty(skeletonKey))
+                                continue;
+
+                            var boneTransform = binding->TransformTrackToBoneIndices;
+                            if (boneTransform.Length <= 0 || boneTransform.Length > 10000)
+                            {
+                                _logger.LogDebug("Invalid bone transform length {length} for skeleton {skel} (hash={hash})",
+                                    boneTransform.Length, skeletonKey, hash);
+                                continue;
+                            }
+
+                            if (!tempSets.TryGetValue(skeletonKey, out var set))
+                            {
+                                set = [];
+                                tempSets[skeletonKey] = set;
+                            }
+
+                            for (int boneIdx = 0; boneIdx < boneTransform.Length; boneIdx++)
+                            {
+                                var v = boneTransform[boneIdx];
+                                if (v < 0 || v > ushort.MaxValue)
+                                    continue;
+                                set.Add((ushort)v);
+                            }
                         }
                     }
                 }
             }
-        }
+            catch (SEHException ex)
-        catch (Exception ex)
-        {
-            _logger.LogWarning(ex, "Could not load havok file in {path}", tempHavokDataPath);
-            return null;
-        }
-        finally
-        {
-            if (tempHavokDataPathAnsi != IntPtr.Zero)
-                Marshal.FreeHGlobal(tempHavokDataPathAnsi);
-
-            try
             {
-                if (File.Exists(tempHavokDataPath))
+                _logger.LogError(ex, "SEH exception processing PAP file {hash} from {path}. Error code: 0x{code:X}",
-                    File.Delete(tempHavokDataPath);
+                    hash, tempHavokDataPath, ex.ErrorCode);
+                return null;
             }
             catch (Exception ex)
             {
-                _logger.LogTrace(ex, "Could not delete temporary havok file: {path}", tempHavokDataPath);
+                _logger.LogError(ex, "Managed exception loading havok file {hash} from {path}", hash, tempHavokDataPath);
+                return null;
             }
+            finally
+            {
+                if (tempHavokDataPathAnsi != IntPtr.Zero)
+                    Marshal.FreeHGlobal(tempHavokDataPathAnsi);
+
+                int retryCount = 3;
+                while (retryCount > 0 && File.Exists(tempHavokDataPath))
+                {
+                    try
+                    {
+                        File.Delete(tempHavokDataPath);
+                        break;
+                    }
+                    catch (IOException ex)
+                    {
+                        retryCount--;
+                        if (retryCount == 0)
+                        {
+                            _logger.LogDebug(ex, "Failed to delete temporary havok file after retries: {path}", tempHavokDataPath);
+                        }
+                        else
+                        {
+                            Thread.Sleep(50);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogDebug(ex, "Unexpected error deleting temporary havok file: {path}", tempHavokDataPath);
+                        break;
+                    }
+                }
+            }
+
+            if (tempSets.Count == 0)
+            {
+                _logger.LogDebug("No bone sets found in PAP file (hash={hash})", hash);
+                return null;
+            }
+
+            var output = new Dictionary<string, List<ushort>>(tempSets.Count, StringComparer.OrdinalIgnoreCase);
+            foreach (var (key, set) in tempSets)
+            {
+                if (set.Count == 0) continue;
+
+                var list = set.ToList();
+                list.Sort();
+                output[key] = list;
+            }
+
+            if (output.Count == 0)
+                return null;
+
+            _configService.Current.BonesDictionary[hash] = output;
+
+            if (persistToConfig)
+                _configService.Save();
+
+            return output;
         }
-
+        catch (Exception ex)
-        if (tempSets.Count == 0)
-            return null;
-
-        var output = new Dictionary<string, List<ushort>>(tempSets.Count, StringComparer.OrdinalIgnoreCase);
-        foreach (var (key, set) in tempSets)
         {
-            if (set.Count == 0) continue;
+            _logger.LogError(ex, "Outer exception reading PAP file (hash={hash})", hash);
-
-            var list = set.ToList();
-            list.Sort();
-            output[key] = list;
-        }
-
-        if (output.Count == 0)
             return null;
+        }
+    }
 
-        _configService.Current.BonesDictionary[hash] = output;
+    private static bool IsValidPointer(IntPtr ptr)
+    {
+        if (ptr == IntPtr.Zero)
+            return false;
 
-        if (persistToConfig)
+        try
-            _configService.Save();
+        {
-
+            _ = Marshal.ReadByte(ptr);
-        return output;
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
     }
 
 

LightlessSync/UI/CompactUI.cs

@@ -52,12 +52,8 @@ public class CompactUi : WindowMediatorSubscriberBase
     private readonly LightlessConfigService _configService;
     private readonly LightlessMediator _lightlessMediator;
     private readonly PairLedger _pairLedger;
-    private readonly ConcurrentDictionary<GameObjectHandler, IReadOnlyDictionary<string, FileDownloadStatus>> _currentDownloads = new();
-    private readonly DrawEntityFactory _drawEntityFactory;
-    private readonly FileUploadManager _fileTransferManager;
     private readonly PlayerPerformanceConfigService _playerPerformanceConfig;
     private readonly PairUiService _pairUiService;
-    private readonly PlayerPerformanceConfigService _playerPerformanceConfig;
     private readonly ServerConfigurationManager _serverManager;
     private readonly TagHandler _tagHandler;
     private readonly UiSharedService _uiSharedService;
@@ -171,9 +167,12 @@ public class CompactUi : WindowMediatorSubscriberBase
         Mediator.Subscribe<SwitchToIntroUiMessage>(this, (_) => IsOpen = false);
         Mediator.Subscribe<CutsceneStartMessage>(this, (_) => UiSharedService_GposeStart());
         Mediator.Subscribe<CutsceneEndMessage>(this, (_) => UiSharedService_GposeEnd());
-        Mediator.Subscribe<DownloadStartedMessage>(this, (msg) => _currentDownloads[msg.DownloadId] = msg.DownloadStatus);
+        Mediator.Subscribe<DownloadStartedMessage>(this, msg =>
+        {
+            _currentDownloads[msg.DownloadId] = new Dictionary<string, FileDownloadStatus>(msg.DownloadStatus, StringComparer.Ordinal);
+        });
         Mediator.Subscribe<DownloadFinishedMessage>(this, (msg) => _currentDownloads.TryRemove(msg.DownloadId, out _));
-        Mediator.Subscribe<RefreshUiMessage>(this, (msg) => _drawFolders = DrawFolders.ToList());
+        Mediator.Subscribe<RefreshUiMessage>(this, (msg) => _drawFolders = [.. DrawFolders]);
 
         _characterAnalyzer = characterAnalyzer;
         _playerPerformanceConfig = playerPerformanceConfig;

LightlessSync/UI/DownloadUi.cs

@@ -65,12 +65,14 @@ public class DownloadUi : WindowMediatorSubscriberBase
 
         IsOpen = true;
 
-        Mediator.Subscribe<DownloadStartedMessage>(this, (msg) => 
+        Mediator.Subscribe<DownloadStartedMessage>(this, msg =>
         {
             _currentDownloads[msg.DownloadId] = msg.DownloadStatus;
-            // Capture initial totals when download starts
+
-            var totalFiles = msg.DownloadStatus.Values.Sum(s => s.TotalFiles);
+            var snap = msg.DownloadStatus.ToArray();
-            var totalBytes = msg.DownloadStatus.Values.Sum(s => s.TotalBytes);
+            var totalFiles = snap.Sum(kv => kv.Value?.TotalFiles ?? 0);
+            var totalBytes = snap.Sum(kv => kv.Value?.TotalBytes ?? 0);
+
             _downloadInitialTotals[msg.DownloadId] = (totalFiles, totalBytes);
             _notificationDismissed = false;
         });
@@ -79,7 +81,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
             _currentDownloads.TryRemove(msg.DownloadId, out _);
             
             // Dismiss notification if all downloads are complete
-            if (!_currentDownloads.Any() && !_notificationDismissed)
+            if (_currentDownloads.IsEmpty && !_notificationDismissed)
             {
                 Mediator.Publish(new LightlessNotificationDismissMessage("pair_download_progress"));
                 _notificationDismissed = true;
@@ -474,7 +476,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
             totalBytes += playerTotalBytes;
             transferredBytes += playerTransferredBytes;
 
-            // per-player W/Q/P/D
+            // per-player W/Q/P/D/C
             var playerDlSlot = 0;
             var playerDlQueue = 0;
             var playerDlProg = 0;
@@ -487,6 +489,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
                 switch (fileStatus.DownloadStatus)
                 {
                     case DownloadStatus.Initializing:
+                    case DownloadStatus.WaitingForQueue:
                         playerDlQueue++;
                         totalDlQueue++;
                         break;
@@ -494,10 +497,6 @@ public class DownloadUi : WindowMediatorSubscriberBase
                         playerDlSlot++;
                         totalDlSlot++;
                         break;
-                    case DownloadStatus.WaitingForQueue:
-                        playerDlQueue++;
-                        totalDlQueue++;
-                        break;
                     case DownloadStatus.Downloading:
                         playerDlProg++;
                         totalDlProg++;
@@ -550,11 +549,6 @@ public class DownloadUi : WindowMediatorSubscriberBase
         if (totalFiles == 0 || totalBytes == 0)
             return;
 
-        // max speed for per-player bar scale (clamped)
-        double maxSpeed = perPlayer.Count > 0 ? perPlayer.Max(p => p.SpeedBytesPerSecond) : 0;
-        if (maxSpeed <= 0)
-            maxSpeed = 1;
-
         var drawList = ImGui.GetBackgroundDrawList();
         var windowPos = ImGui.GetWindowPos();
 

LightlessSync/WebAPI/Files/FileDownloadManager.cs

@@ -504,7 +504,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
                             && decompressed.LongLength != expectedRawSize)
                         {
                             await _fileCompactor.WriteAllBytesAsync(filePath, Array.Empty<byte>(), ct).ConfigureAwait(false);
-                            PersistFileToStorage(fileHash, filePath, repl.GamePath, skipDownscale);
+                            PersistFileToStorage(fileHash, filePath, repl.GamePath, skipDownscale, skipDecimation);
                             continue;
                         }
 
@@ -526,7 +526,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
 
                                 // write to file without compacting during download
                                 await File.WriteAllBytesAsync(filePath, decompressed, ct).ConfigureAwait(false);
-                                PersistFileToStorage(fileHash, filePath, repl.GamePath, skipDownscale);
+                                PersistFileToStorage(fileHash, filePath, repl.GamePath, skipDownscale, skipDecimation);
                             }, ct).ConfigureAwait(false);
                         }
                         finally