"improving" pair handler clean up and some other stuff

LightlessSync/FileCache/FileCacheManager.cs

@@ -280,6 +280,26 @@ public sealed class FileCacheManager : IHostedService
         return CreateFileEntity(cacheFolder, CachePrefix, fi);
     }
 
+    public FileCacheEntity? CreateCacheEntryWithKnownHash(string path, string hash)
+    {
+        if (string.IsNullOrWhiteSpace(hash))
+        {
+            return CreateCacheEntry(path);
+        }
+
+        FileInfo fi = new(path);
+        if (!fi.Exists) return null;
+        _logger.LogTrace("Creating cache entry for {path} using provided hash", path);
+        var cacheFolder = _configService.Current.CacheFolder;
+        if (string.IsNullOrEmpty(cacheFolder)) return null;
+        if (!TryBuildPrefixedPath(fi.FullName, cacheFolder, CachePrefix, out var prefixedPath, out _))
+        {
+            return null;
+        }
+
+        return CreateFileCacheEntity(fi, prefixedPath, hash);
+    }
+
     public FileCacheEntity? CreateFileEntry(string path)
     {
         FileInfo fi = new(path);

LightlessSync/Interop/Ipc/IpcManager.cs

@@ -5,6 +5,8 @@ namespace LightlessSync.Interop.Ipc;
 
 public sealed partial class IpcManager : DisposableMediatorSubscriberBase
 {
+    private bool _wasInitialized;
+
     public IpcManager(ILogger<IpcManager> logger, LightlessMediator mediator,
         IpcCallerPenumbra penumbraIpc, IpcCallerGlamourer glamourerIpc, IpcCallerCustomize customizeIpc, IpcCallerHeels heelsIpc,
         IpcCallerHonorific honorificIpc, IpcCallerMoodles moodlesIpc, IpcCallerPetNames ipcCallerPetNames, IpcCallerBrio ipcCallerBrio) : base(logger, mediator)
@@ -18,7 +20,8 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
         PetNames = ipcCallerPetNames;
         Brio = ipcCallerBrio;
 
-        if (Initialized)
+        _wasInitialized = Initialized;
+        if (_wasInitialized)
         {
             Mediator.Publish(new PenumbraInitializedMessage());
         }
@@ -58,5 +61,13 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
         Moodles.CheckAPI();
         PetNames.CheckAPI();
         Brio.CheckAPI();
+
+        var initialized = Initialized;
+        if (initialized && !_wasInitialized)
+        {
+            Mediator.Publish(new PenumbraInitializedMessage());
+        }
+
+        _wasInitialized = initialized;
     }
 }

LightlessSync/LightlessPlugin.cs

@@ -74,6 +74,7 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService
     private readonly DalamudUtilService _dalamudUtil;
     private readonly LightlessConfigService _lightlessConfigService;
     private readonly ServerConfigurationManager _serverConfigurationManager;
+    private readonly PairHandlerRegistry _pairHandlerRegistry;
     private readonly IServiceScopeFactory _serviceScopeFactory;
     private IServiceScope? _runtimeServiceScope;
     private Task? _launchTask = null;
@@ -81,11 +82,13 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService
     public LightlessPlugin(ILogger<LightlessPlugin> logger, LightlessConfigService lightlessConfigService,
         ServerConfigurationManager serverConfigurationManager,
         DalamudUtilService dalamudUtil,
+        PairHandlerRegistry pairHandlerRegistry,
         IServiceScopeFactory serviceScopeFactory, LightlessMediator mediator) : base(logger, mediator)
     {
         _lightlessConfigService = lightlessConfigService;
         _serverConfigurationManager = serverConfigurationManager;
         _dalamudUtil = dalamudUtil;
+        _pairHandlerRegistry = pairHandlerRegistry;
         _serviceScopeFactory = serviceScopeFactory;
     }
 
@@ -108,12 +111,20 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService
 
     public Task StopAsync(CancellationToken cancellationToken)
     {
+        Logger.LogDebug("Halting LightlessPlugin");
+        try
+        {
+            _pairHandlerRegistry.ResetAllHandlers();
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Failed to reset pair handlers on shutdown");
+        }
+
         UnsubscribeAll();
 
         DalamudUtilOnLogOut();
 
-        Logger.LogDebug("Halting LightlessPlugin");
-
         return Task.CompletedTask;
     }
     

LightlessSync/PlayerData/Pairs/PairCoordinator.Users.cs

@@ -125,6 +125,7 @@ public sealed partial class PairCoordinator
             }
         }
 
+        _mediator.Publish(new PairOnlineMessage(new PairUniqueIdentifier(dto.User.UID)));
         PublishPairDataChanged();
     }
 

LightlessSync/PlayerData/Pairs/PairHandlerAdapter.cs

@@ -1,5 +1,6 @@
 using System.Collections.Concurrent;
 using System.Diagnostics;
+using Dalamud.Plugin.Services;
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Data.Extensions;
@@ -48,6 +49,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     private readonly PairPerformanceMetricsCache _performanceMetricsCache;
     private readonly PenumbraTempCollectionJanitor _tempCollectionJanitor;
     private readonly PairManager _pairManager;
+    private readonly IFramework _framework;
     private CancellationTokenSource? _applicationCancellationTokenSource;
     private Guid _applicationId;
     private Task? _applicationTask;
@@ -66,6 +68,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     private int _lastMissingNonCriticalMods;
     private int _lastMissingForbiddenMods;
     private bool _lastMissingCachedFiles;
+    private string? _lastSuccessfulDataHash;
     private bool _isVisible;
     private Guid _penumbraCollection;
     private readonly object _collectionGate = new();
@@ -82,6 +85,13 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     private readonly object _visibilityGraceGate = new();
     private CancellationTokenSource? _visibilityGraceCts;
     private static readonly TimeSpan VisibilityEvictionGrace = TimeSpan.FromMinutes(1);
+    private readonly object _ownedRetryGate = new();
+    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);
     private static readonly HashSet<string> NonPriorityModExtensions = new(StringComparer.OrdinalIgnoreCase)
     {
         ".tmb",
@@ -95,10 +105,15 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     private DateTime _nextActorLookupUtc = DateTime.MinValue;
     private static readonly TimeSpan ActorLookupInterval = TimeSpan.FromSeconds(1);
     private static readonly SemaphoreSlim ActorInitializationLimiter = new(1, 1);
+    private const int FullyLoadedTimeoutMsPlayer = 30000;
+    private const int FullyLoadedTimeoutMsOther = 5000;
     private readonly object _actorInitializationGate = new();
     private ActorObjectService.ActorDescriptor? _pendingActorDescriptor;
     private bool _actorInitializationInProgress;
     private bool _frameworkUpdateSubscribed;
+    private nint _lastKnownAddress = nint.Zero;
+    private ushort _lastKnownObjectIndex = ushort.MaxValue;
+    private string? _lastKnownName;
 
     public DateTime? InvisibleSinceUtc => _invisibleSinceUtc;
     public DateTime? VisibilityEvictionDueAtUtc => _visibilityEvictionDueAtUtc;
@@ -175,6 +190,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         FileDownloadManager transferManager,
         PluginWarningNotificationService pluginWarningNotificationManager,
         DalamudUtilService dalamudUtil,
+        IFramework framework,
         ActorObjectService actorObjectService,
         IHostApplicationLifetime lifetime,
         FileCacheManager fileDbManager,
@@ -193,6 +209,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         _downloadManager = transferManager;
         _pluginWarningNotificationManager = pluginWarningNotificationManager;
         _dalamudUtil = dalamudUtil;
+        _framework = framework;
         _actorObjectService = actorObjectService;
         _lifetime = lifetime;
         _fileDbManager = fileDbManager;
@@ -432,7 +449,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
     }
 
-    private void ResetPenumbraCollection(bool releaseFromPenumbra = true, string? reason = null)
+    private void ResetPenumbraCollection(bool releaseFromPenumbra = true, string? reason = null, bool awaitIpc = true)
     {
         Guid toRelease = Guid.Empty;
         bool hadCollection = false;
@@ -466,16 +483,33 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             return;
         }
 
-        try
+        var applicationId = Guid.NewGuid();
+        if (awaitIpc)
         {
-            var applicationId = Guid.NewGuid();
+            try
-            Logger.LogTrace("[{applicationId}] Removing temp collection {CollectionId} for {handler} ({reason})", applicationId, toRelease, GetLogIdentifier(), reason ?? "Cleanup");
+            {
-            _ipcManager.Penumbra.RemoveTemporaryCollectionAsync(Logger, applicationId, toRelease).GetAwaiter().GetResult();
+                Logger.LogTrace("[{applicationId}] Removing temp collection {CollectionId} for {handler} ({reason})", applicationId, toRelease, GetLogIdentifier(), reason ?? "Cleanup");
+                _ipcManager.Penumbra.RemoveTemporaryCollectionAsync(Logger, applicationId, toRelease).GetAwaiter().GetResult();
+            }
+            catch (Exception ex)
+            {
+                Logger.LogDebug(ex, "Failed to remove temporary Penumbra collection for {handler}", GetLogIdentifier());
+            }
+            return;
         }
-        catch (Exception ex)
+
+        _ = Task.Run(async () =>
         {
-            Logger.LogDebug(ex, "Failed to remove temporary Penumbra collection for {handler}", GetLogIdentifier());
+            try
-        }
+            {
+                Logger.LogTrace("[{applicationId}] Removing temp collection {CollectionId} for {handler} ({reason})", applicationId, toRelease, GetLogIdentifier(), reason ?? "Cleanup");
+                await _ipcManager.Penumbra.RemoveTemporaryCollectionAsync(Logger, applicationId, toRelease).ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                Logger.LogDebug(ex, "Failed to remove temporary Penumbra collection for {handler}", GetLogIdentifier());
+            }
+        });
     }
 
     private bool AnyPair(Func<PairConnection, bool> predicate)
@@ -559,9 +593,11 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
 
         var hasMissingCachedFiles = HasMissingCachedFiles(LastReceivedCharacterData);
+        var missingStarted = !_lastMissingCachedFiles && hasMissingCachedFiles;
         var missingResolved = _lastMissingCachedFiles && !hasMissingCachedFiles;
         _lastMissingCachedFiles = hasMissingCachedFiles;
-        var shouldForce = forced || missingResolved;
+        var shouldForce = forced || missingStarted || missingResolved;
+        var forceApplyCustomization = forced;
 
         if (IsPaused())
         {
@@ -569,7 +605,22 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             return;
         }
 
-        if (shouldForce)
+        var sanitized = CloneAndSanitizeLastReceived(out var dataHash);
+        if (sanitized is null)
+        {
+            Logger.LogTrace("Sanitized data null for {Ident}", Ident);
+            return;
+        }
+        var dataApplied = !string.IsNullOrEmpty(dataHash)
+            && string.Equals(dataHash, _lastSuccessfulDataHash ?? string.Empty, StringComparison.Ordinal);
+        var needsApply = !dataApplied;
+        var hasModReplacements = sanitized.FileReplacements.Values.Any(list => list.Count > 0);
+        var needsModReapply = needsApply && hasModReplacements;
+        var shouldForceMods = shouldForce || needsModReapply;
+        forceApplyCustomization = forced || needsApply;
+        var suppressForcedModRedraw = !forced && hasMissingCachedFiles && dataApplied;
+
+        if (shouldForceMods)
         {
             _forceApplyMods = true;
             _forceFullReapply = true;
@@ -579,15 +630,21 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             LastAppliedApproximateEffectiveVRAMBytes = -1;
         }
 
-        var sanitized = CloneAndSanitizeLastReceived(out _);
-        if (sanitized is null)
-        {
-            Logger.LogTrace("Sanitized data null for {Ident}", Ident);
-            return;
-        }
-
         _pairStateCache.Store(Ident, sanitized);
 
+        if (!IsVisible && !_pauseRequested)
+        {
+            if (_charaHandler is not null && _charaHandler.Address == nint.Zero)
+            {
+                _charaHandler.Refresh();
+            }
+
+            if (PlayerCharacter != nint.Zero)
+            {
+                IsVisible = true;
+            }
+        }
+
         if (!IsVisible)
         {
             Logger.LogTrace("Handler for {Ident} not visible, caching sanitized data for later", Ident);
@@ -596,7 +653,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             return;
         }
 
-        ApplyCharacterData(Guid.NewGuid(), sanitized, shouldForce);
+        ApplyCharacterData(Guid.NewGuid(), sanitized, forceApplyCustomization, suppressForcedModRedraw);
     }
 
     public bool FetchPerformanceMetricsFromCache()
@@ -906,7 +963,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         SetUploading(false);
     }
 
-    public void ApplyCharacterData(Guid applicationBase, CharacterData characterData, bool forceApplyCustomization = false)
+    public void ApplyCharacterData(Guid applicationBase, CharacterData characterData, bool forceApplyCustomization = false, bool suppressForcedModRedraw = false)
     {
         _lastApplyAttemptAt = DateTime.UtcNow;
         ClearFailureState();
@@ -1000,7 +1057,8 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter), EventSeverity.Informational,
             "Applying Character Data")));
 
-        var charaDataToUpdate = characterData.CheckUpdatedData(applicationBase, _cachedData?.DeepClone() ?? new(), Logger, this, forceApplyCustomization, _forceApplyMods);
+        var charaDataToUpdate = characterData.CheckUpdatedData(applicationBase, _cachedData?.DeepClone() ?? new(), Logger, this,
+            forceApplyCustomization, _forceApplyMods, suppressForcedModRedraw);
 
         if (handlerReady && _forceApplyMods)
         {
@@ -1097,12 +1155,183 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }, CancellationToken.None);
     }
 
+    private void ScheduleOwnedObjectRetry(ObjectKind kind, HashSet<PlayerChanges> changes)
+    {
+        if (kind == ObjectKind.Player || changes.Count == 0)
+        {
+            return;
+        }
+
+        lock (_ownedRetryGate)
+        {
+            _pendingOwnedChanges[kind] = new HashSet<PlayerChanges>(changes);
+            if (!_ownedRetryTask.IsCompleted)
+            {
+                return;
+            }
+
+            _ownedRetryCts = _ownedRetryCts?.CancelRecreate() ?? new CancellationTokenSource();
+            var token = _ownedRetryCts.Token;
+            _ownedRetryTask = Task.Run(() => OwnedObjectRetryLoopAsync(token), CancellationToken.None);
+        }
+    }
+
+    private void ClearOwnedObjectRetry(ObjectKind kind)
+    {
+        lock (_ownedRetryGate)
+        {
+            if (!_pendingOwnedChanges.Remove(kind))
+            {
+                return;
+            }
+        }
+    }
+
+    private void ClearAllOwnedObjectRetries()
+    {
+        lock (_ownedRetryGate)
+        {
+            _pendingOwnedChanges.Clear();
+        }
+    }
+
+    private bool IsOwnedRetryDataStale()
+    {
+        if (!_lastDataReceivedAt.HasValue)
+        {
+            return true;
+        }
+
+        return DateTime.UtcNow - _lastDataReceivedAt.Value > OwnedRetryStaleDataGrace;
+    }
+
+    private async Task OwnedObjectRetryLoopAsync(CancellationToken token)
+    {
+        var delay = OwnedRetryInitialDelay;
+        try
+        {
+            while (!token.IsCancellationRequested)
+            {
+                if (IsOwnedRetryDataStale())
+                {
+                    ClearAllOwnedObjectRetries();
+                    return;
+                }
+
+                Dictionary<ObjectKind, HashSet<PlayerChanges>> pending;
+                lock (_ownedRetryGate)
+                {
+                    if (_pendingOwnedChanges.Count == 0)
+                    {
+                        return;
+                    }
+
+                    pending = _pendingOwnedChanges.ToDictionary(kvp => kvp.Key, kvp => new HashSet<PlayerChanges>(kvp.Value));
+                }
+
+                if (!IsVisible || IsPaused() || !CanApplyNow() || PlayerCharacter == nint.Zero || _charaHandler is null)
+                {
+                    await Task.Delay(delay, token).ConfigureAwait(false);
+                    delay = IncreaseRetryDelay(delay);
+                    continue;
+                }
+
+                if ((_applicationTask?.IsCompleted ?? true) == false || (_pairDownloadTask?.IsCompleted ?? true) == false)
+                {
+                    await Task.Delay(delay, token).ConfigureAwait(false);
+                    delay = IncreaseRetryDelay(delay);
+                    continue;
+                }
+
+                var sanitized = CloneAndSanitizeLastReceived(out _);
+                if (sanitized is null)
+                {
+                    await Task.Delay(delay, token).ConfigureAwait(false);
+                    delay = IncreaseRetryDelay(delay);
+                    continue;
+                }
+
+                bool anyApplied = false;
+                foreach (var entry in pending)
+                {
+                    if (!HasAppearanceDataForKind(sanitized, entry.Key))
+                    {
+                        ClearOwnedObjectRetry(entry.Key);
+                        continue;
+                    }
+
+                    var applied = await ApplyCustomizationDataAsync(Guid.NewGuid(), entry, sanitized, token).ConfigureAwait(false);
+                    if (applied)
+                    {
+                        ClearOwnedObjectRetry(entry.Key);
+                        anyApplied = true;
+                    }
+                }
+
+                if (!anyApplied)
+                {
+                    await Task.Delay(delay, token).ConfigureAwait(false);
+                    delay = IncreaseRetryDelay(delay);
+                }
+                else
+                {
+                    delay = OwnedRetryInitialDelay;
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // ignore
+        }
+        catch (Exception ex)
+        {
+            Logger.LogDebug(ex, "Owned object retry task failed for {handler}", GetLogIdentifier());
+        }
+    }
+
+    private static TimeSpan IncreaseRetryDelay(TimeSpan delay)
+    {
+        var nextMs = Math.Min(delay.TotalMilliseconds * 2, OwnedRetryMaxDelay.TotalMilliseconds);
+        return TimeSpan.FromMilliseconds(nextMs);
+    }
+
+    private static bool HasAppearanceDataForKind(CharacterData data, ObjectKind kind)
+    {
+        if (data.FileReplacements.TryGetValue(kind, out var replacements) && replacements.Count > 0)
+        {
+            return true;
+        }
+
+        if (data.GlamourerData.TryGetValue(kind, out var glamourer) && !string.IsNullOrEmpty(glamourer))
+        {
+            return true;
+        }
+
+        if (data.CustomizePlusData.TryGetValue(kind, out var customize) && !string.IsNullOrEmpty(customize))
+        {
+            return true;
+        }
+
+        return false;
+    }
+
     protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);
 
         SetUploading(false);
         var name = PlayerName;
+        if (!string.IsNullOrEmpty(name))
+        {
+            _lastKnownName = name;
+        }
+
+        var currentAddress = PlayerCharacter;
+        if (currentAddress != nint.Zero)
+        {
+            _lastKnownAddress = currentAddress;
+        }
+
         var user = GetPrimaryUserDataSafe();
         var alias = GetPrimaryAliasOrUidSafe();
         Logger.LogDebug("Disposing {name} ({user})", name, alias);
@@ -1113,6 +1342,9 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             _applicationCancellationTokenSource = null;
             _downloadCancellationTokenSource?.CancelDispose();
             _downloadCancellationTokenSource = null;
+            ClearAllOwnedObjectRetries();
+            _ownedRetryCts?.CancelDispose();
+            _ownedRetryCts = null;
             _downloadManager.Dispose();
             _charaHandler?.Dispose();
             CancelVisibilityGraceTask();
@@ -1125,43 +1357,62 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                 Mediator.Publish(new EventMessage(new Event(name, user, nameof(PairHandlerAdapter), EventSeverity.Informational, "Disposing User")));
             }
 
-            if (_lifetime.ApplicationStopping.IsCancellationRequested) return;
+            if (IsFrameworkUnloading())
-
-            if (_dalamudUtil is { IsZoning: false, IsInCutscene: false } && !string.IsNullOrEmpty(name))
             {
-                Logger.LogTrace("[{applicationId}] Restoring state for {name} ({user})", applicationId, name, alias);
+                Logger.LogWarning("Framework is unloading, skipping disposal for {name} ({user})", name, alias);
-                Logger.LogDebug("[{applicationId}] Removing Temp Collection for {name} ({user})", applicationId, name, alias);
+                return;
-                ResetPenumbraCollection(reason: nameof(Dispose));
+            }
-                if (!IsVisible)
+
+            var isStopping = _lifetime.ApplicationStopping.IsCancellationRequested;
+            if (isStopping)
+            {
+                ResetPenumbraCollection(reason: "DisposeStopping", awaitIpc: false);
+                ScheduleSafeRevertOnDisposal(applicationId, name, alias);
+                return;
+            }
+
+            var canCleanup = !string.IsNullOrEmpty(name)
+                && _dalamudUtil.IsLoggedIn
+                && !_dalamudUtil.IsZoning
+                && !_dalamudUtil.IsInCutscene;
+
+            if (!canCleanup)
+            {
+                return;
+            }
+
+            Logger.LogTrace("[{applicationId}] Restoring state for {name} ({user})", applicationId, name, alias);
+            Logger.LogDebug("[{applicationId}] Removing Temp Collection for {name} ({user})", applicationId, name, alias);
+            ResetPenumbraCollection(reason: nameof(Dispose));
+            if (!IsVisible)
+            {
+                Logger.LogDebug("[{applicationId}] Restoring Glamourer for {name} ({user})", applicationId, name, alias);
+                _ipcManager.Glamourer.RevertByNameAsync(Logger, name, applicationId).GetAwaiter().GetResult();
+            }
+            else
+            {
+                using var cts = new CancellationTokenSource();
+                cts.CancelAfter(TimeSpan.FromSeconds(60));
+
+                var effectiveCachedData = _cachedData ?? _pairStateCache.TryLoad(Ident);
+                if (effectiveCachedData is not null)
                 {
-                    Logger.LogDebug("[{applicationId}] Restoring Glamourer for {name} ({user})", applicationId, name, alias);
+                    _cachedData = effectiveCachedData;
-                    _ipcManager.Glamourer.RevertByNameAsync(Logger, name, applicationId).GetAwaiter().GetResult();
                 }
-                else
+
+                Logger.LogInformation("[{applicationId}] CachedData is null {isNull}, contains things: {contains}",
+                    applicationId, _cachedData == null, _cachedData?.FileReplacements.Any() ?? false);
+
+                foreach (KeyValuePair<ObjectKind, List<FileReplacementData>> item in _cachedData?.FileReplacements ?? [])
                 {
-                    using var cts = new CancellationTokenSource();
+                    try
-                    cts.CancelAfter(TimeSpan.FromSeconds(60));
-
-                    var effectiveCachedData = _cachedData ?? _pairStateCache.TryLoad(Ident);
-                    if (effectiveCachedData is not null)
                     {
-                        _cachedData = effectiveCachedData;
+                        RevertCustomizationDataAsync(item.Key, name, applicationId, cts.Token).GetAwaiter().GetResult();
                     }
-
+                    catch (InvalidOperationException ex)
-                    Logger.LogInformation("[{applicationId}] CachedData is null {isNull}, contains things: {contains}",
-                        applicationId, _cachedData == null, _cachedData?.FileReplacements.Any() ?? false);
-
-                    foreach (KeyValuePair<ObjectKind, List<FileReplacementData>> item in _cachedData?.FileReplacements ?? [])
                     {
-                        try
+                        Logger.LogWarning(ex, "Failed disposing player (not present anymore?)");
-                        {
+                        break;
-                            RevertCustomizationDataAsync(item.Key, name, applicationId, cts.Token).GetAwaiter().GetResult();
-                        }
-                        catch (InvalidOperationException ex)
-                        {
-                            Logger.LogWarning(ex, "Failed disposing player (not present anymore?)");
-                            break;
-                        }
                     }
                 }
             }
@@ -1174,6 +1425,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         {
             PlayerName = null;
             _cachedData = null;
+            _lastSuccessfulDataHash = null;
             _lastAppliedModdedPaths = null;
             _needsCollectionRebuild = false;
             _performanceMetricsCache.Clear(Ident);
@@ -1181,9 +1433,145 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
     }
 
-    private async Task ApplyCustomizationDataAsync(Guid applicationId, KeyValuePair<ObjectKind, HashSet<PlayerChanges>> changes, CharacterData charaData, CancellationToken token)
+    private bool IsFrameworkUnloading()
     {
-        if (PlayerCharacter == nint.Zero) return;
+        try
+        {
+            var prop = _framework.GetType().GetProperty("IsFrameworkUnloading");
+            if (prop?.PropertyType == typeof(bool))
+            {
+                return (bool)prop.GetValue(_framework)!;
+            }
+        }
+        catch
+        {
+            // ignore
+        }
+
+        return false;
+    }
+
+    private void ScheduleSafeRevertOnDisposal(Guid applicationId, string? name, string alias)
+    {
+        var cleanupName = !string.IsNullOrEmpty(name) ? name : _lastKnownName;
+        var cleanupAddress = _lastKnownAddress != nint.Zero
+            ? _lastKnownAddress
+            : _dalamudUtil.GetPlayerCharacterFromCachedTableByIdent(Ident);
+        var cleanupObjectIndex = _lastKnownObjectIndex;
+        var cleanupIdent = Ident;
+        var customizeIds = _customizeIds.Values.Where(id => id.HasValue)
+            .Select(id => id!.Value)
+            .Distinct()
+            .ToList();
+
+        if (string.IsNullOrEmpty(cleanupName)
+            && cleanupAddress == nint.Zero
+            && cleanupObjectIndex == ushort.MaxValue
+            && customizeIds.Count == 0)
+        {
+            return;
+        }
+
+        _ = Task.Run(() => SafeRevertOnDisposalAsync(
+            applicationId,
+            cleanupName,
+            cleanupAddress,
+            cleanupObjectIndex,
+            cleanupIdent,
+            customizeIds,
+            alias));
+    }
+
+    private async Task SafeRevertOnDisposalAsync(
+        Guid applicationId,
+        string? cleanupName,
+        nint cleanupAddress,
+        ushort cleanupObjectIndex,
+        string cleanupIdent,
+        IReadOnlyList<Guid> customizeIds,
+        string alias)
+    {
+        try
+        {
+            if (IsFrameworkUnloading())
+            {
+                return;
+            }
+
+            if (!string.IsNullOrEmpty(cleanupName) && _ipcManager.Glamourer.APIAvailable)
+            {
+                Logger.LogDebug("[{applicationId}] Restoring Glamourer for {name} ({user})", applicationId, cleanupName, alias);
+                await _ipcManager.Glamourer.RevertByNameAsync(Logger, cleanupName, applicationId).ConfigureAwait(false);
+            }
+
+            if (_ipcManager.CustomizePlus.APIAvailable && customizeIds.Count > 0)
+            {
+                foreach (var customizeId in customizeIds)
+                {
+                    await _ipcManager.CustomizePlus.RevertByIdAsync(customizeId).ConfigureAwait(false);
+                }
+            }
+
+            var address = cleanupAddress;
+            if (address == nint.Zero && cleanupObjectIndex != ushort.MaxValue)
+            {
+                address = await _dalamudUtil.RunOnFrameworkThread(() =>
+                {
+                    var obj = _dalamudUtil.GetCharacterFromObjectTableByIndex(cleanupObjectIndex);
+                    if (obj is not Dalamud.Game.ClientState.Objects.SubKinds.IPlayerCharacter player)
+                    {
+                        return nint.Zero;
+                    }
+
+                    if (!DalamudUtilService.TryGetHashedCID(player, out var hash)
+                        || !string.Equals(hash, cleanupIdent, StringComparison.Ordinal))
+                    {
+                        return nint.Zero;
+                    }
+
+                    return player.Address;
+                }).ConfigureAwait(false);
+            }
+
+            if (address == nint.Zero)
+            {
+                return;
+            }
+
+            if (_ipcManager.CustomizePlus.APIAvailable)
+            {
+                await _ipcManager.CustomizePlus.RevertAsync(address).ConfigureAwait(false);
+            }
+
+            if (_ipcManager.Heels.APIAvailable)
+            {
+                await _ipcManager.Heels.RestoreOffsetForPlayerAsync(address).ConfigureAwait(false);
+            }
+
+            if (_ipcManager.Honorific.APIAvailable)
+            {
+                await _ipcManager.Honorific.ClearTitleAsync(address).ConfigureAwait(false);
+            }
+
+            if (_ipcManager.Moodles.APIAvailable)
+            {
+                await _ipcManager.Moodles.RevertStatusAsync(address).ConfigureAwait(false);
+            }
+
+            if (_ipcManager.PetNames.APIAvailable)
+            {
+                await _ipcManager.PetNames.ClearPlayerData(address).ConfigureAwait(false);
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.LogDebug(ex, "Failed shutdown cleanup for {name}", cleanupName ?? cleanupIdent);
+        }
+    }
+
+    private async Task<bool> ApplyCustomizationDataAsync(Guid applicationId, KeyValuePair<ObjectKind, HashSet<PlayerChanges>> changes, CharacterData charaData, CancellationToken token)
+    {
+        if (PlayerCharacter == nint.Zero) return false;
         var ptr = PlayerCharacter;
 
         var handler = changes.Key switch
@@ -1199,14 +1587,29 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         {
             if (handler.Address == nint.Zero)
             {
-                return;
+                return false;
             }
 
             Logger.LogDebug("[{applicationId}] Applying Customization Data for {handler}", applicationId, handler);
-            await _dalamudUtil.WaitWhileCharacterIsDrawing(Logger, handler, applicationId, 30000, token).ConfigureAwait(false);
+            await handler.IsBeingDrawnRunOnFrameworkAsync().ConfigureAwait(false);
+            if (handler.ObjectKind != ObjectKind.Player
+                && handler.CurrentDrawCondition == GameObjectHandler.DrawCondition.DrawObjectZero)
+            {
+                Logger.LogDebug("[{applicationId}] Skipping customization apply for {handler}, draw object not available", applicationId, handler);
+                return false;
+            }
+
+            var drawTimeoutMs = handler.ObjectKind == ObjectKind.Player ? 30000 : 5000;
+            var fullyLoadedTimeoutMs = handler.ObjectKind == ObjectKind.Player ? FullyLoadedTimeoutMsPlayer : FullyLoadedTimeoutMsOther;
+            await _dalamudUtil.WaitWhileCharacterIsDrawing(Logger, handler, applicationId, drawTimeoutMs, token).ConfigureAwait(false);
             if (handler.Address != nint.Zero)
             {
-                await _actorObjectService.WaitForFullyLoadedAsync(handler.Address, token).ConfigureAwait(false);
+                var fullyLoaded = await _actorObjectService.WaitForFullyLoadedAsync(handler.Address, token, fullyLoadedTimeoutMs).ConfigureAwait(false);
+                if (!fullyLoaded)
+                {
+                    Logger.LogDebug("[{applicationId}] Timed out waiting for {handler} to fully load, skipping customization apply", applicationId, handler);
+                    return false;
+                }
             }
 
             token.ThrowIfCancellationRequested();
@@ -1270,6 +1673,8 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             {
                 await _ipcManager.Penumbra.RedrawAsync(Logger, handler, applicationId, token).ConfigureAwait(false);
             }
+
+            return true;
         }
         finally
         {
@@ -1577,37 +1982,25 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                 RecordFailure("Handler not available for application", "HandlerUnavailable");
                 return;
             }
-            _applicationCancellationTokenSource = _applicationCancellationTokenSource.CancelRecreate() ?? new CancellationTokenSource();
 
-            if (_applicationTask != null && !_applicationTask.IsCompleted)
+            var appToken = _applicationCancellationTokenSource?.Token;
+            while ((!_applicationTask?.IsCompleted ?? false)
+                   && !downloadToken.IsCancellationRequested
+                   && (!appToken?.IsCancellationRequested ?? false))
             {
-                Logger.LogDebug("[BASE-{appBase}] Cancelling current data application (Id: {id}) for player ({handler})", applicationBase, _applicationId, PlayerName);
+                Logger.LogDebug("[BASE-{appBase}] Waiting for current data application (Id: {id}) for player ({handler}) to finish",
-
+                    applicationBase, _applicationId, PlayerName);
-                var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
+                await Task.Delay(250).ConfigureAwait(false);
-                var combinedCts = CancellationTokenSource.CreateLinkedTokenSource(downloadToken, timeoutCts.Token);
-
-                try
-                {
-                    await _applicationTask.WaitAsync(combinedCts.Token).ConfigureAwait(false);
-                }
-                catch (OperationCanceledException)
-                {
-                    Logger.LogWarning("[BASE-{appBase}] Timeout waiting for application task {id} to complete, proceeding anyway", applicationBase, _applicationId);
-                }
-                finally
-                {
-                    timeoutCts.Dispose();
-                    combinedCts.Dispose();
-                }
             }
 
-            if (downloadToken.IsCancellationRequested)
+            if (downloadToken.IsCancellationRequested || (appToken?.IsCancellationRequested ?? false))
             {
                 _forceFullReapply = true;
                 RecordFailure("Application cancelled", "Cancellation");
                 return;
             }
 
+            _applicationCancellationTokenSource = _applicationCancellationTokenSource.CancelRecreate() ?? new CancellationTokenSource();
             var token = _applicationCancellationTokenSource.Token;
 
             _applicationTask = ApplyCharacterDataAsync(applicationBase, handlerForApply, charaData, updatedData, updateModdedPaths, updateManip, moddedPaths, wantsModApply, pendingModReapply, token);
@@ -1630,7 +2023,17 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             await _dalamudUtil.WaitWhileCharacterIsDrawing(Logger, handlerForApply, _applicationId, 30000, token).ConfigureAwait(false);
             if (handlerForApply.Address != nint.Zero)
             {
-                await _actorObjectService.WaitForFullyLoadedAsync(handlerForApply.Address, token).ConfigureAwait(false);
+                var fullyLoaded = await _actorObjectService.WaitForFullyLoadedAsync(handlerForApply.Address, token, FullyLoadedTimeoutMsPlayer).ConfigureAwait(false);
+                if (!fullyLoaded)
+                {
+                    Logger.LogDebug("[BASE-{applicationId}] Timed out waiting for {handler} to fully load, caching data for later application",
+                        applicationBase, GetLogIdentifier());
+                    _cachedData = charaData;
+                    _pairStateCache.Store(Ident, charaData);
+                    _forceFullReapply = true;
+                    RecordFailure("Actor not fully loaded within timeout", "FullyLoadedTimeout");
+                    return;
+                }
             }
 
             token.ThrowIfCancellationRequested();
@@ -1692,7 +2095,15 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
 
             foreach (var kind in updatedData)
             {
-                await ApplyCustomizationDataAsync(_applicationId, kind, charaData, token).ConfigureAwait(false);
+                var applied = await ApplyCustomizationDataAsync(_applicationId, kind, charaData, token).ConfigureAwait(false);
+                if (applied)
+                {
+                    ClearOwnedObjectRetry(kind.Key);
+                }
+                else if (kind.Key != ObjectKind.Player)
+                {
+                    ScheduleOwnedObjectRetry(kind.Key, kind.Value);
+                }
                 token.ThrowIfCancellationRequested();
             }
 
@@ -1714,6 +2125,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
 
         StorePerformanceMetrics(charaData);
+        _lastSuccessfulDataHash = GetDataHashSafe(charaData);
         _lastSuccessfulApplyAt = DateTime.UtcNow;
         ClearFailureState();
         Logger.LogDebug("[{applicationId}] Application finished", _applicationId);
@@ -1827,6 +2239,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     {
         IsVisible = false;
         _charaHandler?.Invalidate();
+        ClearAllOwnedObjectRetries();
         _downloadCancellationTokenSource?.CancelDispose();
         _downloadCancellationTokenSource = null;
         if (logChange)
@@ -1839,6 +2252,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     {
         PlayerName = name;
         _charaHandler = _gameObjectHandlerFactory.Create(ObjectKind.Player, () => _dalamudUtil.GetPlayerCharacterFromCachedTableByIdent(Ident), isWatched: false).GetAwaiter().GetResult();
+        UpdateLastKnownActor(_charaHandler.Address, name);
 
         var user = GetPrimaryUserData();
         if (!string.IsNullOrEmpty(user.UID))
@@ -2185,6 +2599,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         if (descriptor.Address == nint.Zero)
             return;
 
+        UpdateLastKnownActor(descriptor);
         RefreshTrackedHandler(descriptor);
         QueueActorInitialization(descriptor);
     }
@@ -2308,6 +2723,29 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         return !string.IsNullOrEmpty(hashedCid);
     }
 
+    private void UpdateLastKnownActor(ActorObjectService.ActorDescriptor descriptor)
+    {
+        _lastKnownAddress = descriptor.Address;
+        _lastKnownObjectIndex = descriptor.ObjectIndex;
+        if (!string.IsNullOrEmpty(descriptor.Name))
+        {
+            _lastKnownName = descriptor.Name;
+        }
+    }
+
+    private void UpdateLastKnownActor(nint address, string? name)
+    {
+        if (address != nint.Zero)
+        {
+            _lastKnownAddress = address;
+        }
+
+        if (!string.IsNullOrEmpty(name))
+        {
+            _lastKnownName = name;
+        }
+    }
+
     private async Task ApplyCustomizeAsync(nint address, string customizeData, ObjectKind kind)
     {
         _customizeIds[kind] = await _ipcManager.CustomizePlus.SetBodyScaleAsync(address, customizeData).ConfigureAwait(false);

LightlessSync/PlayerData/Pairs/PairHandlerAdapterFactory.cs

@@ -7,6 +7,7 @@ using LightlessSync.Services.Mediator;
 using LightlessSync.Services.PairProcessing;
 using LightlessSync.Services.ServerConfiguration;
 using LightlessSync.Services.TextureCompression;
+using Dalamud.Plugin.Services;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
@@ -32,6 +33,7 @@ internal sealed class PairHandlerAdapterFactory : IPairHandlerAdapterFactory
     private readonly PairStateCache _pairStateCache;
     private readonly PairPerformanceMetricsCache _pairPerformanceMetricsCache;
     private readonly PenumbraTempCollectionJanitor _tempCollectionJanitor;
+    private readonly IFramework _framework;
 
     public PairHandlerAdapterFactory(
         ILoggerFactory loggerFactory,
@@ -42,6 +44,7 @@ internal sealed class PairHandlerAdapterFactory : IPairHandlerAdapterFactory
         FileDownloadManagerFactory fileDownloadManagerFactory,
         PluginWarningNotificationService pluginWarningNotificationManager,
         IServiceProvider serviceProvider,
+        IFramework framework,
         IHostApplicationLifetime lifetime,
         FileCacheManager fileCacheManager,
         PlayerPerformanceService playerPerformanceService,
@@ -60,6 +63,7 @@ internal sealed class PairHandlerAdapterFactory : IPairHandlerAdapterFactory
         _fileDownloadManagerFactory = fileDownloadManagerFactory;
         _pluginWarningNotificationManager = pluginWarningNotificationManager;
         _serviceProvider = serviceProvider;
+        _framework = framework;
         _lifetime = lifetime;
         _fileCacheManager = fileCacheManager;
         _playerPerformanceService = playerPerformanceService;
@@ -86,6 +90,7 @@ internal sealed class PairHandlerAdapterFactory : IPairHandlerAdapterFactory
             downloadManager,
             _pluginWarningNotificationManager,
             dalamudUtilService,
+            _framework,
             actorObjectService,
             _lifetime,
             _fileCacheManager,

LightlessSync/PlayerData/Pairs/VisibleUserDataDistributor.cs

@@ -50,6 +50,7 @@ public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
         });
 
         Mediator.Subscribe<ConnectedMessage>(this, (_) => PushToAllVisibleUsers());
+        Mediator.Subscribe<PairOnlineMessage>(this, (msg) => HandlePairOnline(msg.PairIdent));
         Mediator.Subscribe<DisconnectedMessage>(this, (_) =>
         {
             _fileTransferManager.CancelUpload();
@@ -111,6 +112,20 @@ public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
         _ = PushCharacterDataAsync(forced);
     }
 
+    private void HandlePairOnline(PairUniqueIdentifier pairIdent)
+    {
+        if (!_apiController.IsConnected || !_pairLedger.IsPairVisible(pairIdent))
+        {
+            return;
+        }
+
+        if (_pairLedger.GetHandler(pairIdent)?.UserData is { } user)
+        {
+            _usersToPushDataTo.Add(user);
+            PushCharacterData(forced: true);
+        }
+    }
+
     private async Task PushCharacterDataAsync(bool forced = false)
     {
         await _pushLock.WaitAsync(_runtimeCts.Token).ConfigureAwait(false);
@@ -152,5 +167,6 @@ public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
         }
     }
 
-    private List<UserData> GetVisibleUsers() => [.. _pairLedger.GetVisiblePairs().Select(connection => connection.User)];
+    private List<UserData> GetVisibleUsers()
+        => [.. _pairLedger.GetVisiblePairs().Where(connection => connection.IsOnline).Select(connection => connection.User)];
 }

LightlessSync/Plugin.cs

@@ -105,6 +105,7 @@ public sealed class Plugin : IDalamudPlugin
         services.AddSingleton(new WindowSystem("LightlessSync"));
         services.AddSingleton<FileDialogManager>();
         services.AddSingleton(new Dalamud.Localization("LightlessSync.Localization.", string.Empty, useEmbedded: true));
+        services.AddSingleton(framework);
         services.AddSingleton(gameGui);
         services.AddSingleton(gameInteropProvider);
         services.AddSingleton(addonLifecycle);

LightlessSync/Services/ActorTracking/ActorObjectService.cs

@@ -213,18 +213,25 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         return false;
     }
 
-    public async Task WaitForFullyLoadedAsync(nint address, CancellationToken cancellationToken = default)
+    public async Task<bool> WaitForFullyLoadedAsync(nint address, CancellationToken cancellationToken = default, int timeOutMs = 30000)
     {
         if (address == nint.Zero)
             throw new ArgumentException("Address cannot be zero.", nameof(address));
 
+        var timeoutAt = timeOutMs > 0 ? Environment.TickCount64 + timeOutMs : long.MaxValue;
         while (true)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
-            var isLoaded = await _framework.RunOnFrameworkThread(() => IsObjectFullyLoaded(address)).ConfigureAwait(false);
+            var loadState = await _framework.RunOnFrameworkThread(() => GetObjectLoadState(address)).ConfigureAwait(false);
-            if (!IsZoning && isLoaded)
+            if (!loadState.IsValid)
-                return;
+                return false;
+
+            if (!IsZoning && loadState.IsLoaded)
+                return true;
+
+            if (Environment.TickCount64 >= timeoutAt)
+                return false;
 
             await Task.Delay(100, cancellationToken).ConfigureAwait(false);
         }
@@ -1143,6 +1150,18 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         return results;
     }
 
+    private LoadState GetObjectLoadState(nint address)
+    {
+        if (address == nint.Zero)
+            return LoadState.Invalid;
+
+        var obj = _objectTable.CreateObjectReference(address);
+        if (obj is null || obj.Address != address)
+            return LoadState.Invalid;
+
+        return new LoadState(true, IsObjectFullyLoaded(address));
+    }
+
     private static unsafe bool IsObjectFullyLoaded(nint address)
     {
         if (address == nint.Zero)
@@ -1169,6 +1188,11 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         return true;
     }
 
+    private readonly record struct LoadState(bool IsValid, bool IsLoaded)
+    {
+        public static LoadState Invalid => new(false, false);
+    }
+
     private sealed record OwnedObjectSnapshot(
         IReadOnlyList<nint> RenderedPlayers,
         IReadOnlyList<nint> RenderedCompanions,

LightlessSync/Services/Mediator/Messages.cs

@@ -104,6 +104,7 @@ public record PairUiUpdatedMessage(PairUiSnapshot Snapshot) : MessageBase;
 public record CensusUpdateMessage(byte Gender, byte RaceId, byte TribeId) : MessageBase;
 public record TargetPairMessage(Pair Pair) : MessageBase;
 public record PairFocusCharacterMessage(Pair Pair) : SameThreadMessage;
+public record PairOnlineMessage(PairUniqueIdentifier PairIdent) : MessageBase;
 public record CombatStartMessage : MessageBase;
 public record CombatEndMessage : MessageBase;
 public record PerformanceStartMessage : MessageBase;

LightlessSync/Services/TextureCompression/TextureDownscaleService.cs

@@ -77,16 +77,39 @@ public sealed class TextureDownscaleService
     }
 
     public void ScheduleDownscale(string hash, string filePath, TextureMapKind mapKind)
+        => ScheduleDownscale(hash, filePath, () => mapKind);
+
+    public void ScheduleDownscale(string hash, string filePath, Func<TextureMapKind> mapKindFactory)
     {
         if (!filePath.EndsWith(".tex", StringComparison.OrdinalIgnoreCase)) return;
         if (_activeJobs.ContainsKey(hash)) return;
 
         _activeJobs[hash] = Task.Run(async () =>
         {
+            TextureMapKind mapKind;
+            try
+            {
+                mapKind = mapKindFactory();
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to determine texture map kind for {Hash}; skipping downscale", hash);
+                return;
+            }
+
             await DownscaleInternalAsync(hash, filePath, mapKind).ConfigureAwait(false);
         }, CancellationToken.None);
     }
 
+    public bool ShouldScheduleDownscale(string filePath)
+    {
+        if (!filePath.EndsWith(".tex", StringComparison.OrdinalIgnoreCase))
+            return false;
+
+        var performanceConfig = _playerPerformanceConfigService.Current;
+        return performanceConfig.EnableNonIndexTextureMipTrim || performanceConfig.EnableIndexTextureDownscale;
+    }
+
     public string GetPreferredPath(string hash, string originalPath)
     {
         if (_downscaledPaths.TryGetValue(hash, out var existing) && File.Exists(existing))

LightlessSync/UI/DownloadUi.cs

@@ -206,12 +206,16 @@ public class DownloadUi : WindowMediatorSubscriberBase
             var dlQueue = 0;
             var dlProg = 0;
             var dlDecomp = 0;
+            var dlComplete = 0;
 
             foreach (var entry in transfer.Value)
             {
                 var fileStatus = entry.Value;
                 switch (fileStatus.DownloadStatus)
                 {
+                    case DownloadStatus.Initializing:
+                        dlQueue++;
+                        break;
                     case DownloadStatus.WaitingForSlot:
                         dlSlot++;
                         break;
@@ -224,15 +228,20 @@ public class DownloadUi : WindowMediatorSubscriberBase
                     case DownloadStatus.Decompressing:
                         dlDecomp++;
                         break;
+                    case DownloadStatus.Completed:
+                        dlComplete++;
+                        break;
                 }
             }
 
+            var isAllComplete = dlComplete > 0 && dlProg == 0 && dlDecomp == 0 && dlQueue == 0 && dlSlot == 0;
+
             string statusText;
             if (dlProg > 0)
             {
                 statusText = "Downloading";
             }
-            else if (dlDecomp > 0 || (totalBytes > 0 && transferredBytes >= totalBytes))
+            else if (dlDecomp > 0)
             {
                 statusText = "Decompressing";
             }
@@ -244,6 +253,10 @@ public class DownloadUi : WindowMediatorSubscriberBase
             {
                 statusText = "Waiting for slot";
             }
+            else if (isAllComplete)
+            {
+                statusText = "Completed";
+            }
             else
             {
                 statusText = "Waiting";
@@ -309,7 +322,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
                     fillPercent = transferredBytes / (double)totalBytes;
                     showFill = true;
                 }
-                else if (dlDecomp > 0 || transferredBytes >= totalBytes)
+                else if (dlDecomp > 0 || dlComplete > 0 || transferredBytes >= totalBytes)
                 {
                     fillPercent = 1.0;
                     showFill = true;
@@ -341,10 +354,14 @@ public class DownloadUi : WindowMediatorSubscriberBase
                     downloadText =
                         $"{statusText} {UiSharedService.ByteToString(transferredBytes, addSuffix: false)}/{UiSharedService.ByteToString(totalBytes)}";
                 }
-                else if ((dlDecomp > 0 || transferredBytes >= totalBytes) && hasValidSize)
+                else if (dlDecomp > 0)
                 {
                     downloadText = "Decompressing";
                 }
+                else if (isAllComplete)
+                {
+                    downloadText = "Completed";
+                }
                 else
                 {
                     // Waiting states
@@ -417,6 +434,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
         var totalDlQueue = 0;
         var totalDlProg = 0;
         var totalDlDecomp = 0;
+        var totalDlComplete = 0;
 
         var perPlayer = new List<(
             string Name,
@@ -428,7 +446,8 @@ public class DownloadUi : WindowMediatorSubscriberBase
             int DlSlot,
             int DlQueue,
             int DlProg,
-            int DlDecomp)>();
+            int DlDecomp,
+            int DlComplete)>();
 
         foreach (var transfer in _currentDownloads)
         {
@@ -450,12 +469,17 @@ public class DownloadUi : WindowMediatorSubscriberBase
             var playerDlQueue = 0;
             var playerDlProg = 0;
             var playerDlDecomp = 0;
+            var playerDlComplete = 0;
 
             foreach (var entry in transfer.Value)
             {
                 var fileStatus = entry.Value;
                 switch (fileStatus.DownloadStatus)
                 {
+                    case DownloadStatus.Initializing:
+                        playerDlQueue++;
+                        totalDlQueue++;
+                        break;
                     case DownloadStatus.WaitingForSlot:
                         playerDlSlot++;
                         totalDlSlot++;
@@ -472,6 +496,10 @@ public class DownloadUi : WindowMediatorSubscriberBase
                         playerDlDecomp++;
                         totalDlDecomp++;
                         break;
+                    case DownloadStatus.Completed:
+                        playerDlComplete++;
+                        totalDlComplete++;
+                        break;
                 }
             }
 
@@ -497,7 +525,8 @@ public class DownloadUi : WindowMediatorSubscriberBase
                 playerDlSlot,
                 playerDlQueue,
                 playerDlProg,
-                playerDlDecomp
+                playerDlDecomp,
+                playerDlComplete
             ));
         }
 
@@ -521,7 +550,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
 
         // Overall texts
         var headerText =
-            $"Downloading {transferredFiles}/{totalFiles} files [W:{totalDlSlot}/Q:{totalDlQueue}/P:{totalDlProg}/D:{totalDlDecomp}]";
+            $"Downloading {transferredFiles}/{totalFiles} files [W:{totalDlSlot}/Q:{totalDlQueue}/P:{totalDlProg}/D:{totalDlDecomp}/C:{totalDlComplete}]";
 
         var bytesText =
             $"{UiSharedService.ByteToString(transferredBytes, addSuffix: false)}/{UiSharedService.ByteToString(totalBytes)}";
@@ -544,7 +573,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
             foreach (var p in perPlayer)
             {
                 var line =
-                    $"{p.Name} [W:{p.DlSlot}/Q:{p.DlQueue}/P:{p.DlProg}/D:{p.DlDecomp}] {p.TransferredFiles}/{p.TotalFiles}";
+                    $"{p.Name} [W:{p.DlSlot}/Q:{p.DlQueue}/P:{p.DlProg}/D:{p.DlDecomp}/C:{p.DlComplete}] {p.TransferredFiles}/{p.TotalFiles}";
 
                 var lineSize = ImGui.CalcTextSize(line);
                 if (lineSize.X > contentWidth)
@@ -662,7 +691,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
                           && p.TransferredBytes > 0; 
 
             var labelLine =
-                $"{p.Name} [W:{p.DlSlot}/Q:{p.DlQueue}/P:{p.DlProg}/D:{p.DlDecomp}] {p.TransferredFiles}/{p.TotalFiles}";
+                $"{p.Name} [W:{p.DlSlot}/Q:{p.DlQueue}/P:{p.DlProg}/D:{p.DlDecomp}/C:{p.DlComplete}] {p.TransferredFiles}/{p.TotalFiles}";
 
             if (!showBar)
             {
@@ -721,13 +750,18 @@ public class DownloadUi : WindowMediatorSubscriberBase
             // Text inside bar: downloading vs decompressing
             string barText;
 
-            var isDecompressing = p.DlDecomp > 0 && p.TransferredBytes >= p.TotalBytes && p.TotalBytes > 0;
+            var isDecompressing = p.DlDecomp > 0;
+            var isAllComplete = p.DlComplete > 0 && p.DlProg == 0 && p.DlDecomp == 0 && p.DlQueue == 0 && p.DlSlot == 0;
 
             if (isDecompressing)
             {
                 // Keep bar full, static text showing decompressing
                 barText = "Decompressing...";
             }
+            else if (isAllComplete)
+            {
+                barText = "Completed";
+            }
             else
             {
                 var bytesInside =
@@ -808,6 +842,7 @@ public class DownloadUi : WindowMediatorSubscriberBase
             var dlQueue = 0;
             var dlProg = 0;
             var dlDecomp = 0;
+            var dlComplete = 0;
             long totalBytes = 0;
             long transferredBytes = 0;
 
@@ -817,22 +852,29 @@ public class DownloadUi : WindowMediatorSubscriberBase
                 var fileStatus = entry.Value;
                 switch (fileStatus.DownloadStatus)
                 {
+                    case DownloadStatus.Initializing: dlQueue++; break;
                     case DownloadStatus.WaitingForSlot: dlSlot++; break;
                     case DownloadStatus.WaitingForQueue: dlQueue++; break;
                     case DownloadStatus.Downloading: dlProg++; break;
                     case DownloadStatus.Decompressing: dlDecomp++; break;
+                    case DownloadStatus.Completed: dlComplete++; break;
                 }
                 totalBytes += fileStatus.TotalBytes;
                 transferredBytes += fileStatus.TransferredBytes;
             }
 
             var progress = totalBytes > 0 ? (float)transferredBytes / totalBytes : 0f;
+            if (dlComplete > 0 && dlProg == 0 && dlDecomp == 0 && dlQueue == 0 && dlSlot == 0)
+            {
+                progress = 1f;
+            }
             
             string status;
             if (dlDecomp > 0) status = "decompressing";
             else if (dlProg > 0) status = "downloading";
             else if (dlQueue > 0) status = "queued";
             else if (dlSlot > 0) status = "waiting";
+            else if (dlComplete > 0) status = "completed";
             else status = "completed";
 
             downloadStatus.Add((item.Key.Name, progress, status));

LightlessSync/UI/SettingsUi.cs

@@ -863,10 +863,11 @@ public class SettingsUi : WindowMediatorSubscriberBase
 
         _uiShared.DrawHelpText(
             $"The download window will show the current progress of outstanding downloads.{Environment.NewLine}{Environment.NewLine}" +
-            $"What do W/Q/P/D stand for?{Environment.NewLine}W = Waiting for Slot (see Maximum Parallel Downloads){Environment.NewLine}" +
+            $"What do W/Q/P/D/C stand for?{Environment.NewLine}W = Waiting for Slot (see Maximum Parallel Downloads){Environment.NewLine}" +
             $"Q = Queued on Server, waiting for queue ready signal{Environment.NewLine}" +
             $"P = Processing download (aka downloading){Environment.NewLine}" +
-            $"D = Decompressing download");
+            $"D = Decompressing download{Environment.NewLine}" +
+            $"C = Completed download");
         if (!_configService.Current.ShowTransferWindow) ImGui.BeginDisabled();
         ImGui.Indent();
 

LightlessSync/Utils/VariousExtensions.cs

@@ -57,7 +57,8 @@ public static class VariousExtensions
     }
 
     public static Dictionary<ObjectKind, HashSet<PlayerChanges>> CheckUpdatedData(this CharacterData newData, Guid applicationBase,
-        CharacterData? oldData, ILogger logger, IPairPerformanceSubject cachedPlayer, bool forceApplyCustomization, bool forceApplyMods)
+        CharacterData? oldData, ILogger logger, IPairPerformanceSubject cachedPlayer, bool forceApplyCustomization, bool forceApplyMods,
+        bool suppressForcedRedrawOnForcedModApply = false)
     {
         oldData ??= new();
 
@@ -78,6 +79,7 @@ public static class VariousExtensions
 
             bool hasNewAndOldFileReplacements = newFileReplacements != null && existingFileReplacements != null;
             bool hasNewAndOldGlamourerData = newGlamourerData != null && existingGlamourerData != null;
+            var forceRedrawOnForcedApply = forceApplyMods && !suppressForcedRedrawOnForcedModApply;
 
             if (hasNewButNotOldFileReplacements || hasOldButNotNewFileReplacements || hasNewButNotOldGlamourerData || hasOldButNotNewGlamourerData)
             {
@@ -100,7 +102,7 @@ public static class VariousExtensions
                     {
                         logger.LogDebug("[BASE-{appBase}] Updating {object}/{kind} (FileReplacements not equal) => {change}", applicationBase, cachedPlayer, objectKind, PlayerChanges.ModFiles);
                         charaDataToUpdate[objectKind].Add(PlayerChanges.ModFiles);
-                        if (forceApplyMods || objectKind != ObjectKind.Player)
+                        if (objectKind != ObjectKind.Player || forceRedrawOnForcedApply)
                         {
                             charaDataToUpdate[objectKind].Add(PlayerChanges.ForcedRedraw);
                         }
@@ -167,7 +169,7 @@ public static class VariousExtensions
             if (objectKind != ObjectKind.Player) continue;
 
             bool manipDataDifferent = !string.Equals(oldData.ManipulationData, newData.ManipulationData, StringComparison.Ordinal);
-            if (manipDataDifferent || forceApplyMods)
+            if (manipDataDifferent || forceRedrawOnForcedApply)
             {
                 logger.LogDebug("[BASE-{appBase}] Updating {object}/{kind} (Diff manip data) => {change}", applicationBase, cachedPlayer, objectKind, PlayerChanges.ModManip);
                 charaDataToUpdate[objectKind].Add(PlayerChanges.ModManip);

LightlessSync/WebAPI/Files/FileDownloadManager.cs

@@ -28,8 +28,6 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
     private readonly TextureMetadataHelper _textureMetadataHelper;
 
     private readonly ConcurrentDictionary<ThrottledStream, byte> _activeDownloadStreams;
-    private readonly SemaphoreSlim _decompressGate =
-    new(Math.Max(1, Environment.ProcessorCount / 2), Math.Max(1, Environment.ProcessorCount / 2));
 
     private volatile bool _disableDirectDownloads;
     private int _consecutiveDirectDownloadFailures;
@@ -502,18 +500,11 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
         }
     }
 
-    private void RemoveStatus(string key)
-    {
-        lock (_downloadStatusLock)
-        {
-            _downloadStatus.Remove(key);
-        }
-    }
-
     private async Task DecompressBlockFileAsync(
         string downloadStatusKey,
         string blockFilePath,
         Dictionary<string, (string Extension, string GamePath)> replacementLookup,
+        IReadOnlyDictionary<string, long> rawSizeLookup,
         string downloadLabel,
         CancellationToken ct,
         bool skipDownscale)
@@ -542,7 +533,9 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
                         if (!replacementLookup.TryGetValue(fileHash, out var repl))
                         {
                             Logger.LogWarning("{dlName}: No replacement mapping for {fileHash}", downloadLabel, fileHash);
-                            fileBlockStream.Seek(len, SeekOrigin.Current);
+                            // still need to skip bytes:
+                            var skip = checked((int)fileLengthBytes);
+                            fileBlockStream.Position += skip;
                             continue;
                         }
 
@@ -552,37 +545,23 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
 
                         // read compressed data
                         var compressed = new byte[len];
+
                         await ReadExactlyAsync(fileBlockStream, compressed.AsMemory(0, len), ct).ConfigureAwait(false);
 
-                        if (len == 0)
+                        MungeBuffer(compressed);
+                        var decompressed = LZ4Wrapper.Unwrap(compressed);
+
+                        if (rawSizeLookup.TryGetValue(fileHash, out var expectedRawSize)
+                            && expectedRawSize > 0
+                            && decompressed.LongLength != expectedRawSize)
                         {
-                            await _fileCompactor.WriteAllBytesAsync(filePath, Array.Empty<byte>(), ct).ConfigureAwait(false);
+                            Logger.LogWarning("{dlName}: Decompressed size mismatch for {fileHash} (expected {expected}, got {actual})",
-                            PersistFileToStorage(fileHash, filePath, repl.GamePath, skipDownscale);
+                                downloadLabel, fileHash, expectedRawSize, decompressed.LongLength);
                             continue;
                         }
 
-                        MungeBuffer(compressed);
+                        await _fileCompactor.WriteAllBytesAsync(filePath, decompressed, ct).ConfigureAwait(false);
-
+                        PersistFileToStorage(fileHash, filePath, repl.GamePath, skipDownscale);
-                        // limit concurrent decompressions
-                        await _decompressGate.WaitAsync(ct).ConfigureAwait(false);
-                        try
-                        {
-                            var sw = System.Diagnostics.Stopwatch.StartNew();
-
-                            // decompress
-                            var decompressed = LZ4Wrapper.Unwrap(compressed);
-
-                            Logger.LogTrace("{dlName}: Unwrap {fileHash} took {ms}ms (compressed {c} bytes, decompressed {d} bytes)",
-                                downloadLabel, fileHash, sw.ElapsedMilliseconds, compressed.Length, decompressed?.Length ?? -1);
-
-                            // write to file
-                            await _fileCompactor.WriteAllBytesAsync(filePath, decompressed, ct).ConfigureAwait(false);
-                            PersistFileToStorage(fileHash, filePath, repl.GamePath, skipDownscale);
-                        }
-                        finally
-                        {
-                            _decompressGate.Release();
-                        }
                     }
                     catch (EndOfStreamException)
                     {
@@ -594,6 +573,8 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
                     }
                 }
             }
+
+            SetStatus(downloadStatusKey, DownloadStatus.Completed);
         }
         catch (EndOfStreamException)
         {
@@ -603,10 +584,6 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
         {
             Logger.LogError(ex, "{dlName}: Error during block file read", downloadLabel);
         }
-        finally
-        {
-            RemoveStatus(downloadStatusKey);
-        }
     }
 
     public async Task<List<DownloadFileTransfer>> InitiateDownloadList(
@@ -644,21 +621,25 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
             .. await FilesGetSizes(hashes, ct).ConfigureAwait(false),
         ];
 
+        Logger.LogDebug("Files with size 0 or less: {files}",
+            string.Join(", ", downloadFileInfoFromService.Where(f => f.Size <= 0).Select(f => f.Hash)));
+
         foreach (var dto in downloadFileInfoFromService.Where(c => c.IsForbidden))
         {
             if (!_orchestrator.ForbiddenTransfers.Exists(f => string.Equals(f.Hash, dto.Hash, StringComparison.Ordinal)))
                 _orchestrator.ForbiddenTransfers.Add(new DownloadFileTransfer(dto));
         }
 
-        CurrentDownloads = [.. downloadFileInfoFromService
+        CurrentDownloads = downloadFileInfoFromService
             .Distinct()
             .Select(d => new DownloadFileTransfer(d))
-            .Where(d => d.CanBeTransferred)];
+            .Where(d => d.CanBeTransferred)
+            .ToList();
 
         return CurrentDownloads;
     }
 
-    private sealed record BatchChunk(string Key, List<DownloadFileTransfer> Items);
+    private sealed record BatchChunk(string HostKey, string StatusKey, List<DownloadFileTransfer> Items);
 
     private static IEnumerable<List<T>> ChunkList<T>(List<T> items, int chunkSize)
     {
@@ -684,6 +665,20 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
 
         var allowDirectDownloads = ShouldUseDirectDownloads();
         var replacementLookup = BuildReplacementLookup(fileReplacement);
+        var rawSizeLookup = new Dictionary<string, long>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var download in CurrentDownloads)
+        {
+            if (string.IsNullOrWhiteSpace(download.Hash))
+            {
+                continue;
+            }
+
+            if (!rawSizeLookup.TryGetValue(download.Hash, out var existing) || existing <= 0)
+            {
+                rawSizeLookup[download.Hash] = download.TotalRaw;
+            }
+        }
 
         var directDownloads = new List<DownloadFileTransfer>();
         var batchDownloads = new List<DownloadFileTransfer>();
@@ -708,7 +703,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
                 var chunkSize = (int)Math.Ceiling(list.Count / (double)chunkCount);
 
                 return ChunkList(list, chunkSize)
-                    .Select(chunk => new BatchChunk(g.Key, chunk));
+                    .Select((chunk, index) => new BatchChunk(g.Key, $"{g.Key}#{index + 1}", chunk));
             })
             .ToArray();
 
@@ -722,7 +717,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
             {
                 _downloadStatus[d.DirectDownloadUrl!] = new FileDownloadStatus
                 {
-                    DownloadStatus = DownloadStatus.Initializing,
+                    DownloadStatus = DownloadStatus.WaitingForSlot,
                     TotalBytes = d.Total,
                     TotalFiles = 1,
                     TransferredBytes = 0,
@@ -730,12 +725,12 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
                 };
             }
 
-            foreach (var g in batchChunks.GroupBy(c => c.Key, StringComparer.Ordinal))
+            foreach (var chunk in batchChunks)
             {
-                _downloadStatus[g.Key] = new FileDownloadStatus
+                _downloadStatus[chunk.StatusKey] = new FileDownloadStatus
                 {
-                    DownloadStatus = DownloadStatus.Initializing,
+                    DownloadStatus = DownloadStatus.WaitingForQueue,
-                    TotalBytes = g.SelectMany(x => x.Items).Sum(x => x.Total),
+                    TotalBytes = chunk.Items.Sum(x => x.Total),
                     TotalFiles = 1,
                     TransferredBytes = 0,
                     TransferredFiles = 0
@@ -759,13 +754,13 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
         Task batchTask = batchChunks.Length == 0
             ? Task.CompletedTask
             : Parallel.ForEachAsync(batchChunks, new ParallelOptions { MaxDegreeOfParallelism = workerDop, CancellationToken = ct },
-                async (chunk, token) => await ProcessBatchChunkAsync(chunk, replacementLookup, token, skipDownscale).ConfigureAwait(false));
+                async (chunk, token) => await ProcessBatchChunkAsync(chunk, replacementLookup, rawSizeLookup, token, skipDownscale).ConfigureAwait(false));
 
         // direct downloads
         Task directTask = directDownloads.Count == 0
             ? Task.CompletedTask
             : Parallel.ForEachAsync(directDownloads, new ParallelOptions { MaxDegreeOfParallelism = workerDop, CancellationToken = ct },
-                async (d, token) => await ProcessDirectAsync(d, replacementLookup, token, skipDownscale).ConfigureAwait(false));
+                async (d, token) => await ProcessDirectAsync(d, replacementLookup, rawSizeLookup, token, skipDownscale).ConfigureAwait(false));
 
         await Task.WhenAll(batchTask, directTask).ConfigureAwait(false);
 
@@ -773,9 +768,14 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
         ClearDownload();
     }
 
-    private async Task ProcessBatchChunkAsync(BatchChunk chunk, Dictionary<string, (string Extension, string GamePath)> replacementLookup, CancellationToken ct, bool skipDownscale)
+    private async Task ProcessBatchChunkAsync(
+        BatchChunk chunk,
+        Dictionary<string, (string Extension, string GamePath)> replacementLookup,
+        IReadOnlyDictionary<string, long> rawSizeLookup,
+        CancellationToken ct,
+        bool skipDownscale)
     {
-        var statusKey = chunk.Key;
+        var statusKey = chunk.StatusKey;
 
         // enqueue (no slot)
         SetStatus(statusKey, DownloadStatus.WaitingForQueue);
@@ -803,10 +803,11 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
             if (!File.Exists(blockFile))
             {
                 Logger.LogWarning("{dlName}: Block file missing before extraction, skipping", fi.Name);
+                SetStatus(statusKey, DownloadStatus.Completed);
                 return;
             }
 
-            await DecompressBlockFileAsync(statusKey, blockFile, replacementLookup, fi.Name, ct, skipDownscale).ConfigureAwait(false);
+            await DecompressBlockFileAsync(statusKey, blockFile, replacementLookup, rawSizeLookup, fi.Name, ct, skipDownscale).ConfigureAwait(false);
         }
         catch (OperationCanceledException)
         {
@@ -823,7 +824,12 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
         }
     }
 
-    private async Task ProcessDirectAsync(DownloadFileTransfer directDownload, Dictionary<string, (string Extension, string GamePath)> replacementLookup, CancellationToken ct, bool skipDownscale)
+    private async Task ProcessDirectAsync(
+        DownloadFileTransfer directDownload,
+        Dictionary<string, (string Extension, string GamePath)> replacementLookup,
+        IReadOnlyDictionary<string, long> rawSizeLookup,
+        CancellationToken ct,
+        bool skipDownscale)
     {
         var progress = CreateInlineProgress(bytes =>
         {
@@ -833,7 +839,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
 
         if (!ShouldUseDirectDownloads() || string.IsNullOrEmpty(directDownload.DirectDownloadUrl))
         {
-            await ProcessDirectAsQueuedFallbackAsync(directDownload, replacementLookup, progress, ct, skipDownscale).ConfigureAwait(false);
+            await ProcessDirectAsQueuedFallbackAsync(directDownload, replacementLookup, rawSizeLookup, progress, ct, skipDownscale).ConfigureAwait(false);
             return;
         }
 
@@ -861,6 +867,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
             if (!replacementLookup.TryGetValue(directDownload.Hash, out var repl))
             {
                 Logger.LogWarning("{hash}: No replacement data found for direct download.", directDownload.Hash);
+                SetStatus(directDownload.DirectDownloadUrl!, DownloadStatus.Completed);
                 return;
             }
 
@@ -873,13 +880,18 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
             byte[] compressedBytes = await File.ReadAllBytesAsync(tempFilename, ct).ConfigureAwait(false);
             var decompressedBytes = LZ4Wrapper.Unwrap(compressedBytes);
 
+            if (directDownload.TotalRaw > 0 && decompressedBytes.LongLength != directDownload.TotalRaw)
+            {
+                throw new InvalidDataException(
+                    $"{directDownload.Hash}: Decompressed size mismatch (expected {directDownload.TotalRaw}, got {decompressedBytes.LongLength})");
+            }
+
             await _fileCompactor.WriteAllBytesAsync(finalFilename, decompressedBytes, ct).ConfigureAwait(false);
             PersistFileToStorage(directDownload.Hash, finalFilename, repl.GamePath, skipDownscale);
 
             MarkTransferredFiles(directDownload.DirectDownloadUrl!, 1);
+            SetStatus(directDownload.DirectDownloadUrl!, DownloadStatus.Completed);
             Logger.LogDebug("Finished direct download of {hash}.", directDownload.Hash);
-
-            RemoveStatus(directDownload.DirectDownloadUrl!);
         }
         catch (OperationCanceledException ex)
         {
@@ -902,7 +914,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
 
             try
             {
-                await ProcessDirectAsQueuedFallbackAsync(directDownload, replacementLookup, progress, ct, skipDownscale).ConfigureAwait(false);
+                await ProcessDirectAsQueuedFallbackAsync(directDownload, replacementLookup, rawSizeLookup, progress, ct, skipDownscale).ConfigureAwait(false);
 
                 if (!expectedDirectDownloadFailure && failureCount >= 3 && !_disableDirectDownloads)
                 {
@@ -929,6 +941,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
     private async Task ProcessDirectAsQueuedFallbackAsync(
         DownloadFileTransfer directDownload,
         Dictionary<string, (string Extension, string GamePath)> replacementLookup,
+        IReadOnlyDictionary<string, long> rawSizeLookup,
         IProgress<long> progress,
         CancellationToken ct,
         bool skipDownscale)
@@ -956,7 +969,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
             if (!File.Exists(blockFile))
                 throw new FileNotFoundException("Block file missing after direct download fallback.", blockFile);
 
-            await DecompressBlockFileAsync(statusKey, blockFile, replacementLookup, $"fallback-{directDownload.Hash}", ct, skipDownscale)
+            await DecompressBlockFileAsync(statusKey, blockFile, replacementLookup, rawSizeLookup, $"fallback-{directDownload.Hash}", ct, skipDownscale)
                 .ConfigureAwait(false);
         }
         finally
@@ -1003,11 +1016,15 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
 
         try
         {
-            var entry = _fileDbManager.CreateCacheEntry(filePath);
+            var entry = _fileDbManager.CreateCacheEntryWithKnownHash(filePath, fileHash);
-            var mapKind = _textureMetadataHelper.DetermineMapKind(gamePath, filePath);
 
-            if (!skipDownscale)
+            if (!skipDownscale && _textureDownscaleService.ShouldScheduleDownscale(filePath))
-                _textureDownscaleService.ScheduleDownscale(fileHash, filePath, mapKind);
+            {
+                _textureDownscaleService.ScheduleDownscale(
+                    fileHash,
+                    filePath,
+                    () => _textureMetadataHelper.DetermineMapKind(gamePath, filePath));
+            }
 
             if (entry != null && !string.Equals(entry.Hash, fileHash, StringComparison.OrdinalIgnoreCase))
             {

LightlessSync/WebAPI/Files/Models/DownloadStatus.cs

@@ -6,5 +6,6 @@ public enum DownloadStatus
     WaitingForSlot,
     WaitingForQueue,
     Downloading,
-    Decompressing
+    Decompressing,
+    Completed
 }