Changelog

Reviewed-on: #105

LightlessSync/Changelog/changelog.yaml

@@ -1,11 +1,44 @@
-tagline: "Lightless Sync v2.0.0"
+tagline: "Lightless Sync v2.0.1"
 subline: "LIGHTLESS IS EVOLVING!!"
 changelog:
+  - name: "v2.0.1"
+    tagline: "Some Fixes"
+    date: "December 23 2025"
+    # be sure to set this every new version
+    isCurrent: true
+    versions:
+      - number: "Chat"
+        icon: ""
+        items:
+          - "You can turn off the syncshell chat as Owner by going to the Syncshell Admin panel -> Owner -> Enable/Disable Chat."
+          - "Fixed an issue where you can't chat due to regions being in a different language."
+      - number: "LightFinder"
+        icon: ""
+        items:
+          - "The icon/Lightfinder Text will be hidden when Game UI is hidden and behind game elements/UI"
+          - "Able to select an icon for the selected list or a custom glyph if you know the code."
+          - "Smoothing and reducing jitter on the icon/Lightfinder Text."
+          - "Fixed so higher scaled UI options (100/150/200% UI scale) wouldn't break the element."
+          - "Detects if GPose is active, wouldn't render the elements"
+      - number: "Miscellaneous fixes"
+        icon: ""
+        items:
+          - "Fixed the null error given on GetCID when transferring between zones/housing."
+          - "Added push/pop on certain ImGUI elements to remove them after being used. "
+          - "Having all tabs open in the Main UI wouldn't lag out the game anymore."
+          - "Cycle pause has been adjusted to the old function. There is a separate button to pause normally, now called 'Toggle (Un)Pause State'."
+          - "Changes have been made to the character redraw to address the issues with the building character data constantly being redrawn and the redrawn behavior with Honorific titles."
+          - "GPose characters should appear again in the actor screen"
+          - "Lightspeed download console messages are no longer shown as warnings."
+      - number: "Server Updates"
+        icon: ""
+        items:
+          - "Changes have been made to the disabling of your profile. It should save again."
+          - "Ability added to toggle chats from syncshell to be disabled."
+          - "Files are continuously being deleted due to high volumes in storage, potentially causing MCDOs to have missing files. We have increased the limit of the storage in our configurations to see if that helps."
   - name: "v2.0.0"
     tagline: "Thank you for 4 months!"
     date: "December 2025"
-    # be sure to set this every new version
-    isCurrent: true
     versions:
       - number: "Lightless Chat"
         icon: ""

LightlessSync/FileCache/CacheMonitor.cs

@@ -6,6 +6,7 @@ using LightlessSync.Utils;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
 using System.Collections.Immutable;
+using System.IO;
 
 namespace LightlessSync.FileCache;
 
@@ -21,6 +22,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     private CancellationTokenSource _scanCancellationTokenSource = new();
     private readonly CancellationTokenSource _periodicCalculationTokenSource = new();
     public static readonly IImmutableList<string> AllowedFileExtensions = [".mdl", ".tex", ".mtrl", ".tmb", ".pap", ".avfx", ".atex", ".sklb", ".eid", ".phyb", ".pbd", ".scd", ".skp", ".shpk", ".kdb"];
+    private static readonly HashSet<string> AllowedFileExtensionSet = new(AllowedFileExtensions, StringComparer.OrdinalIgnoreCase);
 
     public CacheMonitor(ILogger<CacheMonitor> logger, IpcManager ipcManager, LightlessConfigService configService,
         FileCacheManager fileDbManager, LightlessMediator mediator, PerformanceCollectorService performanceCollector, DalamudUtilService dalamudUtil,
@@ -163,7 +165,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     {
         Logger.LogTrace("Lightless FSW: FileChanged: {change} => {path}", e.ChangeType, e.FullPath);
 
-        if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+        if (!HasAllowedExtension(e.FullPath)) return;
 
         lock (_watcherChanges)
         {
@@ -207,7 +209,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     private void Fs_Changed(object sender, FileSystemEventArgs e)
     {
         if (Directory.Exists(e.FullPath)) return;
-        if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+        if (!HasAllowedExtension(e.FullPath)) return;
 
         if (e.ChangeType is not (WatcherChangeTypes.Changed or WatcherChangeTypes.Deleted or WatcherChangeTypes.Created))
             return;
@@ -231,7 +233,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
             {
                 foreach (var file in directoryFiles)
                 {
-                    if (!AllowedFileExtensions.Any(ext => file.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) continue;
+                    if (!HasAllowedExtension(file)) continue;
                     var oldPath = file.Replace(e.FullPath, e.OldFullPath, StringComparison.OrdinalIgnoreCase);
 
                     _watcherChanges.Remove(oldPath);
@@ -243,7 +245,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
         }
         else
         {
-            if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+            if (!HasAllowedExtension(e.FullPath)) return;
 
             lock (_watcherChanges)
             {
@@ -263,6 +265,17 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     public FileSystemWatcher? PenumbraWatcher { get; private set; }
     public FileSystemWatcher? LightlessWatcher { get; private set; }
 
+    private static bool HasAllowedExtension(string path)
+    {
+        if (string.IsNullOrEmpty(path))
+        {
+            return false;
+        }
+
+        var extension = Path.GetExtension(path);
+        return !string.IsNullOrEmpty(extension) && AllowedFileExtensionSet.Contains(extension);
+    }
+
     private async Task LightlessWatcherExecution()
     {
         _lightlessFswCts = _lightlessFswCts.CancelRecreate();
@@ -606,7 +619,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
                 [
                     .. Directory.GetFiles(folder, "*.*", SearchOption.AllDirectories)
                                             .AsParallel()
-                                            .Where(f => AllowedFileExtensions.Any(e => f.EndsWith(e, StringComparison.OrdinalIgnoreCase))
+                                            .Where(f => HasAllowedExtension(f)
                                                 && !f.Contains(@"\bg\", StringComparison.OrdinalIgnoreCase)
                                                 && !f.Contains(@"\bgcommon\", StringComparison.OrdinalIgnoreCase)
                                                 && !f.Contains(@"\ui\", StringComparison.OrdinalIgnoreCase)),

LightlessSync/FileCache/TransientResourceManager.cs

@@ -59,7 +59,7 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
             _playerRelatedPointers.Remove(msg.GameObjectHandler);
         });
 
-        foreach (var descriptor in _actorObjectService.PlayerDescriptors)
+        foreach (var descriptor in _actorObjectService.ObjectDescriptors)
         {
             HandleActorTracked(descriptor);
         }
@@ -291,7 +291,7 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
         }
 
         var activeDescriptors = new Dictionary<nint, ObjectKind>();
-        foreach (var descriptor in _actorObjectService.PlayerDescriptors)
+        foreach (var descriptor in _actorObjectService.ObjectDescriptors)
         {
             if (TryResolveObjectKind(descriptor, out var resolvedKind))
             {
@@ -372,6 +372,9 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
 
     private void HandleActorTracked(ActorObjectService.ActorDescriptor descriptor)
     {
+        if (descriptor.IsInGpose)
+            return;
+
         if (!TryResolveObjectKind(descriptor, out var resolvedKind))
             return;
 

LightlessSync/Interop/Ipc/IpcCallerMoodles.cs

@@ -1,5 +1,4 @@
-using Dalamud.Game.ClientState.Objects.SubKinds;
+using Dalamud.Plugin;
-using Dalamud.Plugin;
 using Dalamud.Plugin.Ipc;
 using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.Services;
@@ -13,7 +12,7 @@ public sealed class IpcCallerMoodles : IpcServiceBase
     private static readonly IpcServiceDescriptor MoodlesDescriptor = new("Moodles", "Moodles", new Version(0, 0, 0, 0));
 
     private readonly ICallGateSubscriber<int> _moodlesApiVersion;
-    private readonly ICallGateSubscriber<IPlayerCharacter, object> _moodlesOnChange;
+    private readonly ICallGateSubscriber<nint, object> _moodlesOnChange;
     private readonly ICallGateSubscriber<nint, string> _moodlesGetStatus;
     private readonly ICallGateSubscriber<nint, string, object> _moodlesSetStatus;
     private readonly ICallGateSubscriber<nint, object> _moodlesRevertStatus;
@@ -29,7 +28,7 @@ public sealed class IpcCallerMoodles : IpcServiceBase
         _lightlessMediator = lightlessMediator;
 
         _moodlesApiVersion = pi.GetIpcSubscriber<int>("Moodles.Version");
-        _moodlesOnChange = pi.GetIpcSubscriber<IPlayerCharacter, object>("Moodles.StatusManagerModified");
+        _moodlesOnChange = pi.GetIpcSubscriber<nint, object>("Moodles.StatusManagerModified");
         _moodlesGetStatus = pi.GetIpcSubscriber<nint, string>("Moodles.GetStatusManagerByPtrV2");
         _moodlesSetStatus = pi.GetIpcSubscriber<nint, string, object>("Moodles.SetStatusManagerByPtrV2");
         _moodlesRevertStatus = pi.GetIpcSubscriber<nint, object>("Moodles.ClearStatusManagerByPtrV2");
@@ -39,9 +38,9 @@ public sealed class IpcCallerMoodles : IpcServiceBase
         CheckAPI();
     }
 
-    private void OnMoodlesChange(IPlayerCharacter character)
+    private void OnMoodlesChange(nint address)
     {
-        _lightlessMediator.Publish(new MoodlesMessage(character.Address));
+        _lightlessMediator.Publish(new MoodlesMessage(address));
     }
 
     protected override void Dispose(bool disposing)
@@ -107,7 +106,7 @@ public sealed class IpcCallerMoodles : IpcServiceBase
 
         try
         {
-            return _moodlesApiVersion.InvokeFunc() == 3
+            return _moodlesApiVersion.InvokeFunc() >= 4
                 ? IpcConnectionState.Available
                 : IpcConnectionState.VersionMismatch;
         }

LightlessSync/LightlessConfiguration/Configurations/ChatConfig.cs

@@ -11,6 +11,8 @@ public sealed class ChatConfig : ILightlessConfiguration
     public bool ShowRulesOverlayOnOpen { get; set; } = true;
     public bool ShowMessageTimestamps { get; set; } = true;
     public float ChatWindowOpacity { get; set; } = .97f;
+    public bool FadeWhenUnfocused { get; set; } = false;
+    public float UnfocusedWindowOpacity { get; set; } = 0.6f;
     public bool IsWindowPinned { get; set; } = false;
     public bool AutoOpenChatOnPluginLoad { get; set; } = false;
     public float ChatFontScale { get; set; } = 1.0f;

LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs

@@ -49,7 +49,8 @@ public class LightlessConfig : ILightlessConfiguration
     public int DownloadSpeedLimitInBytes { get; set; } = 0;
     public DownloadSpeeds DownloadSpeedType { get; set; } = DownloadSpeeds.MBps;
     public bool PreferNotesOverNamesForVisible { get; set; } = false;
-    public VisiblePairSortMode VisiblePairSortMode { get; set; } = VisiblePairSortMode.Default;
+    public VisiblePairSortMode VisiblePairSortMode { get; set; } = VisiblePairSortMode.Alphabetical;
+    public OnlinePairSortMode OnlinePairSortMode { get; set; } = OnlinePairSortMode.Alphabetical;
     public float ProfileDelay { get; set; } = 1.5f;
     public bool ProfilePopoutRight { get; set; } = false;
     public bool ProfilesAllowNsfw { get; set; } = false;

LightlessSync/LightlessSync.csproj

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

LightlessSync/PlayerData/Factories/PlayerDataFactory.cs

@@ -119,6 +119,7 @@ public class PlayerDataFactory
         CharacterDataFragment fragment = objectKind == ObjectKind.Player ? new CharacterDataFragmentPlayer() : new();
 
         _logger.LogDebug("Building character data for {obj}", playerRelatedObject);
+        var logDebug = _logger.IsEnabled(LogLevel.Debug);
 
         // wait until chara is not drawing and present so nothing spontaneously explodes
         await _dalamudUtil.WaitWhileCharacterIsDrawing(_logger, playerRelatedObject, Guid.NewGuid(), 30000, ct: ct).ConfigureAwait(false);
@@ -132,11 +133,6 @@ public class PlayerDataFactory
 
         ct.ThrowIfCancellationRequested();
 
-        Dictionary<string, List<ushort>>? boneIndices =
-            objectKind != ObjectKind.Player
-            ? null
-            : await _dalamudUtil.RunOnFrameworkThread(() => _modelAnalyzer.GetSkeletonBoneIndices(playerRelatedObject)).ConfigureAwait(false);
-
         DateTime start = DateTime.UtcNow;
 
         // penumbra call, it's currently broken
@@ -154,11 +150,21 @@ public class PlayerDataFactory
 
         ct.ThrowIfCancellationRequested();
 
-        _logger.LogDebug("== Static Replacements ==");
+        if (logDebug)
-        foreach (var replacement in fragment.FileReplacements.Where(i => i.HasFileReplacement).OrderBy(i => i.GamePaths.First(), StringComparer.OrdinalIgnoreCase))
         {
-            _logger.LogDebug("=> {repl}", replacement);
+            _logger.LogDebug("== Static Replacements ==");
-            ct.ThrowIfCancellationRequested();
+            foreach (var replacement in fragment.FileReplacements.Where(i => i.HasFileReplacement).OrderBy(i => i.GamePaths.First(), StringComparer.OrdinalIgnoreCase))
+            {
+                _logger.LogDebug("=> {repl}", replacement);
+                ct.ThrowIfCancellationRequested();
+            }
+        }
+        else
+        {
+            foreach (var replacement in fragment.FileReplacements.Where(i => i.HasFileReplacement))
+            {
+                ct.ThrowIfCancellationRequested();
+            }
         }
 
         await _transientResourceManager.WaitForRecording(ct).ConfigureAwait(false);
@@ -190,11 +196,21 @@ public class PlayerDataFactory
         var transientPaths = ManageSemiTransientData(objectKind);
         var resolvedTransientPaths = await GetFileReplacementsFromPaths(transientPaths, new HashSet<string>(StringComparer.Ordinal)).ConfigureAwait(false);
 
-        _logger.LogDebug("== Transient Replacements ==");
+        if (logDebug)
-        foreach (var replacement in resolvedTransientPaths.Select(c => new FileReplacement([.. c.Value], c.Key)).OrderBy(f => f.ResolvedPath, StringComparer.Ordinal))
         {
-            _logger.LogDebug("=> {repl}", replacement);
+            _logger.LogDebug("== Transient Replacements ==");
-            fragment.FileReplacements.Add(replacement);
+            foreach (var replacement in resolvedTransientPaths.Select(c => new FileReplacement([.. c.Value], c.Key)).OrderBy(f => f.ResolvedPath, StringComparer.Ordinal))
+            {
+                _logger.LogDebug("=> {repl}", replacement);
+                fragment.FileReplacements.Add(replacement);
+            }
+        }
+        else
+        {
+            foreach (var replacement in resolvedTransientPaths.Select(c => new FileReplacement([.. c.Value], c.Key)))
+            {
+                fragment.FileReplacements.Add(replacement);
+            }
         }
 
         // clean up all semi transient resources that don't have any file replacement (aka null resolve)
@@ -252,11 +268,26 @@ public class PlayerDataFactory
 
         ct.ThrowIfCancellationRequested();
 
+        Dictionary<string, List<ushort>>? boneIndices = null;
+        var hasPapFiles = false;
+        if (objectKind == ObjectKind.Player)
+        {
+            hasPapFiles = fragment.FileReplacements.Any(f =>
+                !f.IsFileSwap && f.GamePaths.First().EndsWith("pap", StringComparison.OrdinalIgnoreCase));
+            if (hasPapFiles)
+            {
+                boneIndices = await _dalamudUtil.RunOnFrameworkThread(() => _modelAnalyzer.GetSkeletonBoneIndices(playerRelatedObject)).ConfigureAwait(false);
+            }
+        }
+
         if (objectKind == ObjectKind.Player)
         {
             try
             {
-                await VerifyPlayerAnimationBones(boneIndices, (fragment as CharacterDataFragmentPlayer)!, ct).ConfigureAwait(false);
+                if (hasPapFiles)
+                {
+                    await VerifyPlayerAnimationBones(boneIndices, (fragment as CharacterDataFragmentPlayer)!, ct).ConfigureAwait(false);
+                }
             }
             catch (OperationCanceledException e)
             {
@@ -278,12 +309,16 @@ public class PlayerDataFactory
     {
         if (boneIndices == null) return;
 
-        foreach (var kvp in boneIndices)
+        if (_logger.IsEnabled(LogLevel.Debug))
         {
-            _logger.LogDebug("Found {skellyname} ({idx} bone indices) on player: {bones}", kvp.Key, kvp.Value.Any() ? kvp.Value.Max() : 0, string.Join(',', kvp.Value));
+            foreach (var kvp in boneIndices)
+            {
+                _logger.LogDebug("Found {skellyname} ({idx} bone indices) on player: {bones}", kvp.Key, kvp.Value.Any() ? kvp.Value.Max() : 0, string.Join(',', kvp.Value));
+            }
         }
 
-        if (boneIndices.All(u => u.Value.Count == 0)) return;
+        var maxPlayerBoneIndex = boneIndices.SelectMany(kvp => kvp.Value).DefaultIfEmpty().Max();
+        if (maxPlayerBoneIndex <= 0) return;
 
         int noValidationFailed = 0;
         foreach (var file in fragment.FileReplacements.Where(f => !f.IsFileSwap && f.GamePaths.First().EndsWith("pap", StringComparison.OrdinalIgnoreCase)).ToList())
@@ -303,12 +338,13 @@ public class PlayerDataFactory
 
                 _logger.LogDebug("Verifying bone indices for {path}, found {x} skeletons", file.ResolvedPath, skeletonIndices.Count);
 
-                foreach (var boneCount in skeletonIndices.Select(k => k).ToList())
+                foreach (var boneCount in skeletonIndices)
                 {
-                    if (boneCount.Value.Max() > boneIndices.SelectMany(b => b.Value).Max())
+                    var maxAnimationIndex = boneCount.Value.DefaultIfEmpty().Max();
+                    if (maxAnimationIndex > maxPlayerBoneIndex)
                     {
                         _logger.LogWarning("Found more bone indices on the animation {path} skeleton {skl} (max indice {idx}) than on any player related skeleton (max indice {idx2})",
-                            file.ResolvedPath, boneCount.Key, boneCount.Value.Max(), boneIndices.SelectMany(b => b.Value).Max());
+                            file.ResolvedPath, boneCount.Key, maxAnimationIndex, maxPlayerBoneIndex);
                         validationFailed = true;
                         break;
                     }

LightlessSync/PlayerData/Handlers/GameObjectHandler.cs

@@ -16,6 +16,8 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
     private readonly Func<IntPtr> _getAddress;
     private readonly bool _isOwnedObject;
     private readonly PerformanceCollectorService _performanceCollector;
+    private readonly object _frameworkUpdateGate = new();
+    private bool _frameworkUpdateSubscribed;
     private byte _classJob = 0;
     private Task? _delayedZoningTask;
     private bool _haltProcessing = false;
@@ -47,7 +49,10 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
             });
         }
 
-        Mediator.Subscribe<FrameworkUpdateMessage>(this, (_) => FrameworkUpdate());
+        if (_isOwnedObject)
+        {
+            EnableFrameworkUpdates();
+        }
 
         Mediator.Subscribe<ZoneSwitchEndMessage>(this, (_) => ZoneSwitchEnd());
         Mediator.Subscribe<ZoneSwitchStartMessage>(this, (_) => ZoneSwitchStart());
@@ -109,7 +114,7 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
     {
         while (await _dalamudUtil.RunOnFrameworkThread(() =>
                {
-                   if (_haltProcessing) CheckAndUpdateObject();
+                   EnsureLatestObjectState();
                    if (CurrentDrawCondition != DrawCondition.None) return true;
                    var gameObj = _dalamudUtil.CreateGameObject(Address);
                    if (gameObj is Dalamud.Game.ClientState.Objects.Types.ICharacter chara)
@@ -148,6 +153,11 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
         _haltProcessing = false;
     }
 
+    public void Refresh()
+    {
+        _dalamudUtil.RunOnFrameworkThread(CheckAndUpdateObject).GetAwaiter().GetResult();
+    }
+
     public async Task<bool> IsBeingDrawnRunOnFrameworkAsync()
     {
         return await _dalamudUtil.RunOnFrameworkThread(IsBeingDrawn).ConfigureAwait(false);
@@ -361,7 +371,7 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
 
     private bool IsBeingDrawn()
     {
-        if (_haltProcessing) CheckAndUpdateObject();
+        EnsureLatestObjectState();
 
         if (_dalamudUtil.IsAnythingDrawing)
         {
@@ -373,6 +383,28 @@ public sealed class GameObjectHandler : DisposableMediatorSubscriberBase, IHighP
         return CurrentDrawCondition != DrawCondition.None;
     }
 
+    private void EnsureLatestObjectState()
+    {
+        if (_haltProcessing || !_frameworkUpdateSubscribed)
+        {
+            CheckAndUpdateObject();
+        }
+    }
+
+    private void EnableFrameworkUpdates()
+    {
+        lock (_frameworkUpdateGate)
+        {
+            if (_frameworkUpdateSubscribed)
+            {
+                return;
+            }
+
+            Mediator.Subscribe<FrameworkUpdateMessage>(this, _ => FrameworkUpdate());
+            _frameworkUpdateSubscribed = true;
+        }
+    }
+
     private unsafe DrawCondition IsBeingDrawnUnsafe()
     {
         if (Address == IntPtr.Zero) return DrawCondition.ObjectZero;

LightlessSync/PlayerData/Pairs/IPairHandlerAdapter.cs

@@ -1,36 +1,43 @@
-using LightlessSync.API.Data;
+    using LightlessSync.API.Data;
 
-namespace LightlessSync.PlayerData.Pairs;
+    namespace LightlessSync.PlayerData.Pairs;
 
-/// <summary>
+    /// <summary>
-///     orchestrates the lifecycle of a paired character
+    ///     orchestrates the lifecycle of a paired character
-/// </summary>
+    /// </summary>
-public interface IPairHandlerAdapter : IDisposable, IPairPerformanceSubject
+    public interface IPairHandlerAdapter : IDisposable, IPairPerformanceSubject
-{
+    {
-    new string Ident { get; }
+        new string Ident { get; }
-    bool Initialized { get; }
+        bool Initialized { get; }
-    bool IsVisible { get; }
+        bool IsVisible { get; }
-    bool ScheduledForDeletion { get; set; }
+        bool ScheduledForDeletion { get; set; }
-    CharacterData? LastReceivedCharacterData { get; }
+        CharacterData? LastReceivedCharacterData { get; }
-    long LastAppliedDataBytes { get; }
+        long LastAppliedDataBytes { get; }
-    new string? PlayerName { get; }
+        new string? PlayerName { get; }
-    string PlayerNameHash { get; }
+        string PlayerNameHash { get; }
-    uint PlayerCharacterId { get; }
+        uint PlayerCharacterId { get; }
-    DateTime? LastDataReceivedAt { get; }
+        DateTime? LastDataReceivedAt { get; }
-    DateTime? LastApplyAttemptAt { get; }
+        DateTime? LastApplyAttemptAt { get; }
-    DateTime? LastSuccessfulApplyAt { get; }
+        DateTime? LastSuccessfulApplyAt { get; }
-    string? LastFailureReason { get; }
+        string? LastFailureReason { get; }
-    IReadOnlyList<string> LastBlockingConditions { get; }
+        IReadOnlyList<string> LastBlockingConditions { get; }
-    bool IsApplying { get; }
+        bool IsApplying { get; }
-    bool IsDownloading { get; }
+        bool IsDownloading { get; }
-    int PendingDownloadCount { get; }
+        int PendingDownloadCount { get; }
-    int ForbiddenDownloadCount { get; }
+        int ForbiddenDownloadCount { get; }
+        bool PendingModReapply { get; }
+        bool ModApplyDeferred { get; }
+        int MissingCriticalMods { get; }
+        int MissingNonCriticalMods { get; }
+        int MissingForbiddenMods { get; }
+        DateTime? InvisibleSinceUtc { get; }
+        DateTime? VisibilityEvictionDueAtUtc { get; }
 
     void Initialize();
-    void ApplyData(CharacterData data);
+        void ApplyData(CharacterData data);
-    void ApplyLastReceivedData(bool forced = false);
+        void ApplyLastReceivedData(bool forced = false);
-    bool FetchPerformanceMetricsFromCache();
+        bool FetchPerformanceMetricsFromCache();
-    void LoadCachedCharacterData(CharacterData data);
+        void LoadCachedCharacterData(CharacterData data);
-    void SetUploading(bool uploading);
+        void SetUploading(bool uploading);
-    void SetPaused(bool paused);
+        void SetPaused(bool paused);
-}
+    }

LightlessSync/PlayerData/Pairs/Pair.cs

@@ -87,22 +87,25 @@ public class Pair
             return;
         }
 
-        if (args.Target is not MenuTargetDefault target || target.TargetObjectId != handler.PlayerCharacterId || IsPaused)
+        if (args.Target is not MenuTargetDefault target || target.TargetObjectId != handler.PlayerCharacterId)
         {
             return;
         }
 
-        UiSharedService.AddContextMenuItem(args, name: "Open Profile", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
+        if (!IsPaused)
         {
-            _mediator.Publish(new ProfileOpenStandaloneMessage(this));
+            UiSharedService.AddContextMenuItem(args, name: "Open Profile", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
-            return Task.CompletedTask;
+            {
-        });
+                _mediator.Publish(new ProfileOpenStandaloneMessage(this));
+                return Task.CompletedTask;
+            });
 
-        UiSharedService.AddContextMenuItem(args, name: "Reapply last data", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
+            UiSharedService.AddContextMenuItem(args, name: "Reapply last data", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
-        {
+            {
-            ApplyLastReceivedData(forced: true);
+                ApplyLastReceivedData(forced: true);
-            return Task.CompletedTask;
+                return Task.CompletedTask;
-        });
+            });
+        }
 
         UiSharedService.AddContextMenuItem(args, name: "Change Permissions", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
         {
@@ -110,7 +113,24 @@ public class Pair
             return Task.CompletedTask;
         });
 
-        UiSharedService.AddContextMenuItem(args, name: "Cycle pause state", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
+        if (IsPaused)
+        {
+            UiSharedService.AddContextMenuItem(args, name: "Toggle Unpause State", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
+            {
+                _ = _apiController.Value.UnpauseAsync(UserData);
+                return Task.CompletedTask;
+            });
+        }
+        else
+        {
+            UiSharedService.AddContextMenuItem(args, name: "Toggle Pause State", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
+            {
+                _ = _apiController.Value.PauseAsync(UserData);
+                return Task.CompletedTask;
+            });
+        }
+
+        UiSharedService.AddContextMenuItem(args, name: "Cycle Pause State", prefixChar: 'L', colorMenuItem: _lightlessPrefixColor, onClick: () =>
         {
             TriggerCyclePause();
             return Task.CompletedTask;
@@ -194,9 +214,13 @@ public class Pair
     {
         var handler = TryGetHandler();
         if (handler is null)
-        {
             return PairDebugInfo.Empty;
-        }
+
+        var now = DateTime.UtcNow;
+        var dueAt = handler.VisibilityEvictionDueAtUtc;
+        var remainingSeconds = dueAt.HasValue
+            ? Math.Max(0, (dueAt.Value - now).TotalSeconds)
+            : (double?)null;
 
         return new PairDebugInfo(
             true,
@@ -206,11 +230,19 @@ public class Pair
             handler.LastDataReceivedAt,
             handler.LastApplyAttemptAt,
             handler.LastSuccessfulApplyAt,
+            handler.InvisibleSinceUtc,
+            handler.VisibilityEvictionDueAtUtc,
+            remainingSeconds,
             handler.LastFailureReason,
             handler.LastBlockingConditions,
             handler.IsApplying,
             handler.IsDownloading,
             handler.PendingDownloadCount,
-            handler.ForbiddenDownloadCount);
+            handler.ForbiddenDownloadCount,
+            handler.PendingModReapply,
+            handler.ModApplyDeferred,
+            handler.MissingCriticalMods,
+            handler.MissingNonCriticalMods,
+            handler.MissingForbiddenMods);
     }
 }

LightlessSync/PlayerData/Pairs/PairDebugInfo.cs

@@ -8,12 +8,20 @@ public sealed record PairDebugInfo(
     DateTime? LastDataReceivedAt,
     DateTime? LastApplyAttemptAt,
     DateTime? LastSuccessfulApplyAt,
+    DateTime? InvisibleSinceUtc,
+    DateTime? VisibilityEvictionDueAtUtc,
+    double? VisibilityEvictionRemainingSeconds,
     string? LastFailureReason,
     IReadOnlyList<string> BlockingConditions,
     bool IsApplying,
     bool IsDownloading,
     int PendingDownloadCount,
-    int ForbiddenDownloadCount)
+    int ForbiddenDownloadCount,
+    bool PendingModReapply,
+    bool ModApplyDeferred,
+    int MissingCriticalMods,
+    int MissingNonCriticalMods,
+    int MissingForbiddenMods)
 {
     public static PairDebugInfo Empty { get; } = new(
         false,
@@ -24,9 +32,17 @@ public sealed record PairDebugInfo(
         null,
         null,
         null,
+        null,
+        null,
+        null,
         Array.Empty<string>(),
         false,
         false,
         0,
+        0,
+        false,
+        false,
+        0,
+        0,
         0);
 }

LightlessSync/PlayerData/Pairs/PairHandlerAdapter.cs

@@ -8,6 +8,7 @@ using LightlessSync.Interop.Ipc;
 using LightlessSync.PlayerData.Factories;
 using LightlessSync.PlayerData.Handlers;
 using LightlessSync.Services;
+using LightlessSync.Services.ActorTracking;
 using LightlessSync.Services.Events;
 using LightlessSync.Services.Mediator;
 using LightlessSync.Services.PairProcessing;
@@ -18,6 +19,7 @@ using LightlessSync.WebAPI.Files;
 using LightlessSync.WebAPI.Files.Models;
 using Microsoft.Extensions.Hosting;
 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;
 
@@ -31,6 +33,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     private sealed record CombatData(Guid ApplicationId, CharacterData CharacterData, bool Forced);
 
     private readonly DalamudUtilService _dalamudUtil;
+    private readonly ActorObjectService _actorObjectService;
     private readonly FileDownloadManager _downloadManager;
     private readonly FileCacheManager _fileDbManager;
     private readonly GameObjectHandlerFactory _gameObjectHandlerFactory;
@@ -56,11 +59,15 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     private bool _forceFullReapply;
     private Dictionary<(string GamePath, string? Hash), string>? _lastAppliedModdedPaths;
     private bool _needsCollectionRebuild;
+    private bool _pendingModReapply;
+    private bool _lastModApplyDeferred;
+    private int _lastMissingCriticalMods;
+    private int _lastMissingNonCriticalMods;
+    private int _lastMissingForbiddenMods;
     private bool _isVisible;
     private Guid _penumbraCollection;
     private readonly object _collectionGate = new();
     private bool _redrawOnNextApplication = false;
-    private bool _explicitRedrawQueued;
     private readonly object _initializationGate = new();
     private readonly object _pauseLock = new();
     private Task _pauseTransitionTask = Task.CompletedTask;
@@ -70,7 +77,29 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     private DateTime? _lastSuccessfulApplyAt;
     private string? _lastFailureReason;
     private IReadOnlyList<string> _lastBlockingConditions = Array.Empty<string>();
+    private readonly object _visibilityGraceGate = new();
+    private CancellationTokenSource? _visibilityGraceCts;
+    private static readonly TimeSpan VisibilityEvictionGrace = TimeSpan.FromMinutes(1);
+    private static readonly HashSet<string> NonPriorityModExtensions = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ".tmb",
+        ".pap",
+        ".atex",
+        ".avfx",
+        ".scd"
+    };
+    private DateTime? _invisibleSinceUtc;
+    private DateTime? _visibilityEvictionDueAtUtc;
+    private DateTime _nextActorLookupUtc = DateTime.MinValue;
+    private static readonly TimeSpan ActorLookupInterval = TimeSpan.FromSeconds(1);
+    private static readonly SemaphoreSlim ActorInitializationLimiter = new(1, 1);
+    private readonly object _actorInitializationGate = new();
+    private ActorObjectService.ActorDescriptor? _pendingActorDescriptor;
+    private bool _actorInitializationInProgress;
+    private bool _frameworkUpdateSubscribed;
 
+    public DateTime? InvisibleSinceUtc => _invisibleSinceUtc;
+    public DateTime? VisibilityEvictionDueAtUtc => _visibilityEvictionDueAtUtc;
     public string Ident { get; }
     public bool Initialized { get; private set; }
     public bool ScheduledForDeletion { get; set; }
@@ -80,24 +109,37 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         get => _isVisible;
         private set
         {
-            if (_isVisible != value)
+            if (_isVisible == value) return;
+
+            _isVisible = value;
+
+            if (!_isVisible)
             {
-                _isVisible = value;
+                DisableSync();
-                if (!_isVisible)
+
-                {
+                _invisibleSinceUtc = DateTime.UtcNow;
-                    DisableSync();
+                _visibilityEvictionDueAtUtc = _invisibleSinceUtc.Value.Add(VisibilityEvictionGrace);
-                    ResetPenumbraCollection(reason: "VisibilityLost");
+
-                }
+                StartVisibilityGraceTask();
-                else if (_charaHandler is not null && _charaHandler.Address != nint.Zero)
-                {
-                    _ = EnsurePenumbraCollection();
-                }
-                var user = GetPrimaryUserData();
-                Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter),
-                    EventSeverity.Informational, "User Visibility Changed, now: " + (_isVisible ? "Is Visible" : "Is not Visible"))));
-                Mediator.Publish(new RefreshUiMessage());
-                Mediator.Publish(new VisibilityChange());
             }
+            else
+            {
+                CancelVisibilityGraceTask();
+
+                _invisibleSinceUtc = null;
+                _visibilityEvictionDueAtUtc = null;
+
+                ScheduledForDeletion = false;
+
+                if (_charaHandler is not null && _charaHandler.Address != nint.Zero)
+                    _ = EnsurePenumbraCollection();
+            }
+
+            var user = GetPrimaryUserData();
+            Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter),
+                EventSeverity.Informational, "User Visibility Changed, now: " + (_isVisible ? "Is Visible" : "Is not Visible"))));
+            Mediator.Publish(new RefreshUiMessage());
+            Mediator.Publish(new VisibilityChange());
         }
     }
 
@@ -106,6 +148,11 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     public long LastAppliedApproximateVRAMBytes { get; set; } = -1;
     public long LastAppliedApproximateEffectiveVRAMBytes { get; set; } = -1;
     public CharacterData? LastReceivedCharacterData { get; private set; }
+    public bool PendingModReapply => _pendingModReapply;
+    public bool ModApplyDeferred => _lastModApplyDeferred;
+    public int MissingCriticalMods => _lastMissingCriticalMods;
+    public int MissingNonCriticalMods => _lastMissingNonCriticalMods;
+    public int MissingForbiddenMods => _lastMissingForbiddenMods;
     public DateTime? LastDataReceivedAt => _lastDataReceivedAt;
     public DateTime? LastApplyAttemptAt => _lastApplyAttemptAt;
     public DateTime? LastSuccessfulApplyAt => _lastSuccessfulApplyAt;
@@ -126,6 +173,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         FileDownloadManager transferManager,
         PluginWarningNotificationService pluginWarningNotificationManager,
         DalamudUtilService dalamudUtil,
+        ActorObjectService actorObjectService,
         IHostApplicationLifetime lifetime,
         FileCacheManager fileDbManager,
         PlayerPerformanceService playerPerformanceService,
@@ -142,6 +190,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         _downloadManager = transferManager;
         _pluginWarningNotificationManager = pluginWarningNotificationManager;
         _dalamudUtil = dalamudUtil;
+        _actorObjectService = actorObjectService;
         _lifetime = lifetime;
         _fileDbManager = fileDbManager;
         _playerPerformanceService = playerPerformanceService;
@@ -165,6 +214,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             return;
         }
 
+        ActorObjectService.ActorDescriptor? trackedDescriptor = null;
         lock (_initializationGate)
         {
             if (Initialized)
@@ -178,7 +228,12 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                 _forceApplyMods = true;
             }
 
-            Mediator.Subscribe<FrameworkUpdateMessage>(this, _ => FrameworkUpdate());
+            var useFrameworkUpdate = !_actorObjectService.HooksActive;
+            if (useFrameworkUpdate)
+            {
+                Mediator.Subscribe<FrameworkUpdateMessage>(this, _ => FrameworkUpdate());
+                _frameworkUpdateSubscribed = true;
+            }
             Mediator.Subscribe<ZoneSwitchStartMessage>(this, _ =>
             {
                 _downloadCancellationTokenSource?.CancelDispose();
@@ -214,17 +269,49 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             Mediator.Subscribe<CutsceneEndMessage>(this, _ => EnableSync());
             Mediator.Subscribe<GposeStartMessage>(this, _ => DisableSync());
             Mediator.Subscribe<GposeEndMessage>(this, _ => EnableSync());
-        Mediator.Subscribe<DownloadFinishedMessage>(this, msg =>
+            Mediator.Subscribe<ActorTrackedMessage>(this, msg => HandleActorTracked(msg.Descriptor));
-        {
+            Mediator.Subscribe<ActorUntrackedMessage>(this, msg => HandleActorUntracked(msg.Descriptor));
-            if (_charaHandler is null || !ReferenceEquals(msg.DownloadId, _charaHandler))
+            Mediator.Subscribe<DownloadFinishedMessage>(this, msg =>
             {
-                return;
+                if (_charaHandler is null || !ReferenceEquals(msg.DownloadId, _charaHandler))
+                {
+                    return;
+                }
+
+                if (_pendingModReapply && IsVisible)
+                {
+                    if (LastReceivedCharacterData is not null)
+                    {
+                        Logger.LogDebug("Downloads finished for {handler}, reapplying pending mod data", GetLogIdentifier());
+                        ApplyLastReceivedData(forced: true);
+                        return;
+                    }
+
+                    if (_cachedData is not null)
+                    {
+                        Logger.LogDebug("Downloads finished for {handler}, reapplying pending mod data from cache", GetLogIdentifier());
+                        ApplyCharacterData(Guid.NewGuid(), _cachedData, forceApplyCustomization: true);
+                        return;
+                    }
+                }
+
+                TryApplyQueuedData();
+            });
+
+            if (!useFrameworkUpdate
+                && _actorObjectService.TryGetActorByHash(Ident, out var descriptor)
+                && descriptor.Address != nint.Zero)
+            {
+                trackedDescriptor = descriptor;
             }
-            TryApplyQueuedData();
-        });
 
             Initialized = true;
         }
+
+        if (trackedDescriptor.HasValue)
+        {
+            HandleActorTracked(trackedDescriptor.Value);
+        }
     }
 
     private IReadOnlyList<PairConnection> GetCurrentPairs()
@@ -717,6 +804,67 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         return true;
     }
 
+    private bool IsForbiddenHash(string hash)
+        => _downloadManager.ForbiddenTransfers.Exists(f => string.Equals(f.Hash, hash, StringComparison.Ordinal));
+
+    private static bool IsNonPriorityModPath(string? gamePath)
+    {
+        if (string.IsNullOrEmpty(gamePath))
+        {
+            return false;
+        }
+
+        var extension = Path.GetExtension(gamePath);
+        return !string.IsNullOrEmpty(extension) && NonPriorityModExtensions.Contains(extension);
+    }
+
+    private static bool IsCriticalModReplacement(FileReplacementData replacement)
+    {
+        foreach (var gamePath in replacement.GamePaths)
+        {
+            if (!IsNonPriorityModPath(gamePath))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private void CountMissingReplacements(IEnumerable<FileReplacementData> missing, out int critical, out int nonCritical, out int forbidden)
+    {
+        critical = 0;
+        nonCritical = 0;
+        forbidden = 0;
+
+        foreach (var replacement in missing)
+        {
+            if (IsForbiddenHash(replacement.Hash))
+            {
+                forbidden++;
+            }
+
+            if (IsCriticalModReplacement(replacement))
+            {
+                critical++;
+            }
+            else
+            {
+                nonCritical++;
+            }
+        }
+    }
+
+    private static void RemoveModApplyChanges(Dictionary<ObjectKind, HashSet<PlayerChanges>> updatedData)
+    {
+        foreach (var changes in updatedData.Values)
+        {
+            changes.Remove(PlayerChanges.ModFiles);
+            changes.Remove(PlayerChanges.ModManip);
+            changes.Remove(PlayerChanges.ForcedRedraw);
+        }
+    }
+
     private bool CanApplyNow()
     {
         return !_dalamudUtil.IsInCombat
@@ -740,6 +888,16 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         _lastBlockingConditions = Array.Empty<string>();
     }
 
+    private void DeferApplication(Guid applicationBase, CharacterData characterData, bool forceApplyCustomization, UserData user, string reason,
+        string failureKey, LogLevel logLevel, string logMessage, params object?[] logArgs)
+    {
+        Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter), EventSeverity.Warning, reason)));
+        Logger.Log(logLevel, logMessage, logArgs);
+        RecordFailure(reason, failureKey);
+        _dataReceivedInDowntime = new(applicationBase, characterData, forceApplyCustomization);
+        SetUploading(false);
+    }
+
     public void ApplyCharacterData(Guid applicationBase, CharacterData characterData, bool forceApplyCustomization = false)
     {
         _lastApplyAttemptAt = DateTime.UtcNow;
@@ -757,72 +915,48 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         if (_dalamudUtil.IsInCombat)
         {
             const string reason = "Cannot apply character data: you are in combat, deferring application";
-            Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter), EventSeverity.Warning,
+            DeferApplication(applicationBase, characterData, forceApplyCustomization, user, reason, "Combat", LogLevel.Debug,
-                reason)));
+                "[BASE-{appBase}] Received data but player is in combat", applicationBase);
-            Logger.LogDebug("[BASE-{appBase}] Received data but player is in combat", applicationBase);
-            RecordFailure(reason, "Combat");
-            _dataReceivedInDowntime = new(applicationBase, characterData, forceApplyCustomization);
-            SetUploading(false);
             return;
         }
 
         if (_dalamudUtil.IsPerforming)
         {
             const string reason = "Cannot apply character data: you are performing music, deferring application";
-            Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter), EventSeverity.Warning,
+            DeferApplication(applicationBase, characterData, forceApplyCustomization, user, reason, "Performance", LogLevel.Debug,
-                reason)));
+                "[BASE-{appBase}] Received data but player is performing", applicationBase);
-            Logger.LogDebug("[BASE-{appBase}] Received data but player is performing", applicationBase);
-            RecordFailure(reason, "Performance");
-            _dataReceivedInDowntime = new(applicationBase, characterData, forceApplyCustomization);
-            SetUploading(false);
             return;
         }
 
         if (_dalamudUtil.IsInInstance)
         {
             const string reason = "Cannot apply character data: you are in an instance, deferring application";
-            Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter), EventSeverity.Warning,
+            DeferApplication(applicationBase, characterData, forceApplyCustomization, user, reason, "Instance", LogLevel.Debug,
-                reason)));
+                "[BASE-{appBase}] Received data but player is in instance", applicationBase);
-            Logger.LogDebug("[BASE-{appBase}] Received data but player is in instance", applicationBase);
-            RecordFailure(reason, "Instance");
-            _dataReceivedInDowntime = new(applicationBase, characterData, forceApplyCustomization);
-            SetUploading(false);
             return;
         }
 
         if (_dalamudUtil.IsInCutscene)
         {
             const string reason = "Cannot apply character data: you are in a cutscene, deferring application";
-            Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter), EventSeverity.Warning,
+            DeferApplication(applicationBase, characterData, forceApplyCustomization, user, reason, "Cutscene", LogLevel.Debug,
-                reason)));
+                "[BASE-{appBase}] Received data but player is in a cutscene", applicationBase);
-            Logger.LogDebug("[BASE-{appBase}] Received data but player is in a cutscene", applicationBase);
-            RecordFailure(reason, "Cutscene");
-            _dataReceivedInDowntime = new(applicationBase, characterData, forceApplyCustomization);
-            SetUploading(false);
             return;
         }
 
         if (_dalamudUtil.IsInGpose)
         {
             const string reason = "Cannot apply character data: you are in GPose, deferring application";
-            Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter), EventSeverity.Warning,
+            DeferApplication(applicationBase, characterData, forceApplyCustomization, user, reason, "GPose", LogLevel.Debug,
-                reason)));
+                "[BASE-{appBase}] Received data but player is in GPose", applicationBase);
-            Logger.LogDebug("[BASE-{appBase}] Received data but player is in GPose", applicationBase);
-            RecordFailure(reason, "GPose");
-            _dataReceivedInDowntime = new(applicationBase, characterData, forceApplyCustomization);
-            SetUploading(false);
             return;
         }
 
         if (!_ipcManager.Penumbra.APIAvailable || !_ipcManager.Glamourer.APIAvailable)
         {
             const string reason = "Cannot apply character data: Penumbra or Glamourer is not available, deferring application";
-            Mediator.Publish(new EventMessage(new Event(PlayerName, user, nameof(PairHandlerAdapter), EventSeverity.Warning,
+            DeferApplication(applicationBase, characterData, forceApplyCustomization, user, reason, "PluginUnavailable", LogLevel.Information,
-                reason)));
+                "[BASE-{appbase}] Application of data for {player} while Penumbra/Glamourer unavailable, returning", applicationBase, GetLogIdentifier());
-            Logger.LogInformation("[BASE-{appbase}] Application of data for {player} while Penumbra/Glamourer unavailable, returning", applicationBase, GetLogIdentifier());
-            RecordFailure(reason, "PluginUnavailable");
-            _dataReceivedInDowntime = new(applicationBase, characterData, forceApplyCustomization);
-            SetUploading(false);
             return;
         }
 
@@ -865,13 +999,10 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             _forceApplyMods = false;
         }
 
-        _explicitRedrawQueued = false;
-
         if (_redrawOnNextApplication && charaDataToUpdate.TryGetValue(ObjectKind.Player, out var player))
         {
             player.Add(PlayerChanges.ForcedRedraw);
             _redrawOnNextApplication = false;
-            _explicitRedrawQueued = true;
         }
 
         if (charaDataToUpdate.TryGetValue(ObjectKind.Player, out var playerChanges))
@@ -918,6 +1049,46 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
     }
 
+    private void CancelVisibilityGraceTask()
+    {
+        lock (_visibilityGraceGate)
+        {
+            _visibilityGraceCts?.CancelDispose();
+            _visibilityGraceCts = null;
+        }
+    }
+
+    private void StartVisibilityGraceTask()
+    {
+        CancellationToken token;
+        lock (_visibilityGraceGate)
+        {
+            _visibilityGraceCts = _visibilityGraceCts?.CancelRecreate() ?? new CancellationTokenSource();
+            token = _visibilityGraceCts.Token;
+        }
+
+        _visibilityGraceTask = Task.Run(async () =>
+        {
+            try
+            {
+                await Task.Delay(VisibilityEvictionGrace, token).ConfigureAwait(false);
+                token.ThrowIfCancellationRequested();
+                if (IsVisible) return;
+
+                ScheduledForDeletion = true;
+                ResetPenumbraCollection(reason: "VisibilityLostTimeout");
+            }
+            catch (OperationCanceledException)
+            {
+                // operation cancelled, do nothing
+            }
+            catch (Exception ex)
+            {
+                Logger.LogDebug(ex, "Visibility grace task failed for {handler}", GetLogIdentifier());
+            }
+        }, CancellationToken.None);
+    }
+
     protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);
@@ -936,7 +1107,10 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             _downloadCancellationTokenSource = null;
             _downloadManager.Dispose();
             _charaHandler?.Dispose();
+            CancelVisibilityGraceTask();
             _charaHandler = null;
+            _invisibleSinceUtc = null;
+            _visibilityEvictionDueAtUtc = null;
 
             if (!string.IsNullOrEmpty(name))
             {
@@ -1022,7 +1196,14 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
 
             Logger.LogDebug("[{applicationId}] Applying Customization Data for {handler}", applicationId, handler);
             await _dalamudUtil.WaitWhileCharacterIsDrawing(Logger, handler, applicationId, 30000, token).ConfigureAwait(false);
+            if (handler.Address != nint.Zero)
+            {
+                await _actorObjectService.WaitForFullyLoadedAsync(handler.Address, token).ConfigureAwait(false);
+            }
+
             token.ThrowIfCancellationRequested();
+            var tasks = new List<Task>();
+            bool needsRedraw = false;
             foreach (var change in changes.Value.OrderBy(p => (int)p))
             {
                 Logger.LogDebug("[{applicationId}] Processing {change} for {handler}", applicationId, change, handler);
@@ -1031,45 +1212,39 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                     case PlayerChanges.Customize:
                         if (charaData.CustomizePlusData.TryGetValue(changes.Key, out var customizePlusData))
                         {
-                            _customizeIds[changes.Key] = await _ipcManager.CustomizePlus.SetBodyScaleAsync(handler.Address, customizePlusData).ConfigureAwait(false);
+                            tasks.Add(ApplyCustomizeAsync(handler.Address, customizePlusData, changes.Key));
                         }
                         else if (_customizeIds.TryGetValue(changes.Key, out var customizeId))
                         {
-                            await _ipcManager.CustomizePlus.RevertByIdAsync(customizeId).ConfigureAwait(false);
+                            tasks.Add(RevertCustomizeAsync(customizeId, changes.Key));
-                            _customizeIds.Remove(changes.Key);
                         }
                         break;
 
                     case PlayerChanges.Heels:
-                        await _ipcManager.Heels.SetOffsetForPlayerAsync(handler.Address, charaData.HeelsData).ConfigureAwait(false);
+                        tasks.Add(_ipcManager.Heels.SetOffsetForPlayerAsync(handler.Address, charaData.HeelsData));
                         break;
 
                     case PlayerChanges.Honorific:
-                        await _ipcManager.Honorific.SetTitleAsync(handler.Address, charaData.HonorificData).ConfigureAwait(false);
+                        tasks.Add(_ipcManager.Honorific.SetTitleAsync(handler.Address, charaData.HonorificData));
                         break;
 
                     case PlayerChanges.Glamourer:
                         if (charaData.GlamourerData.TryGetValue(changes.Key, out var glamourerData))
                         {
-                            await _ipcManager.Glamourer.ApplyAllAsync(Logger, handler, glamourerData, applicationId, token).ConfigureAwait(false);
+                            tasks.Add(_ipcManager.Glamourer.ApplyAllAsync(Logger, handler, glamourerData, applicationId, token));
                         }
                         break;
 
                     case PlayerChanges.Moodles:
-                        await _ipcManager.Moodles.SetStatusAsync(handler.Address, charaData.MoodlesData).ConfigureAwait(false);
+                        tasks.Add(_ipcManager.Moodles.SetStatusAsync(handler.Address, charaData.MoodlesData));
                         break;
 
                     case PlayerChanges.PetNames:
-                        await _ipcManager.PetNames.SetPlayerData(handler.Address, charaData.PetNamesData).ConfigureAwait(false);
+                        tasks.Add(_ipcManager.PetNames.SetPlayerData(handler.Address, charaData.PetNamesData));
                         break;
 
                     case PlayerChanges.ForcedRedraw:
-                        if (!ShouldPerformForcedRedraw(changes.Key, changes.Value, charaData))
+                        needsRedraw = true;
-                        {
-                            Logger.LogTrace("[{applicationId}] Skipping forced redraw for {handler}", applicationId, handler);
-                            break;
-                        }
-                        await _ipcManager.Penumbra.RedrawAsync(Logger, handler, applicationId, token).ConfigureAwait(false);
                         break;
 
                     default:
@@ -1077,6 +1252,16 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                 }
                 token.ThrowIfCancellationRequested();
             }
+
+            if (tasks.Count > 0)
+            {
+                await Task.WhenAll(tasks).ConfigureAwait(false);
+            }
+
+            if (needsRedraw)
+            {
+                await _ipcManager.Penumbra.RedrawAsync(Logger, handler, applicationId, token).ConfigureAwait(false);
+            }
         }
         finally
         {
@@ -1084,44 +1269,6 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
     }
 
-    private bool ShouldPerformForcedRedraw(ObjectKind objectKind, ICollection<PlayerChanges> changeSet, CharacterData newData)
-    {
-        if (objectKind != ObjectKind.Player)
-        {
-            return true;
-        }
-
-        var hasModFiles = changeSet.Contains(PlayerChanges.ModFiles);
-        var hasManip = changeSet.Contains(PlayerChanges.ModManip);
-        var modsChanged = hasModFiles && PlayerModFilesChanged(newData, _cachedData);
-        var manipChanged = hasManip && !string.Equals(_cachedData?.ManipulationData, newData.ManipulationData, StringComparison.Ordinal);
-
-        if (modsChanged)
-        {
-            _explicitRedrawQueued = false;
-            return true;
-        }
-
-        if (manipChanged)
-        {
-            _explicitRedrawQueued = false;
-            return true;
-        }
-
-        if (_explicitRedrawQueued)
-        {
-            _explicitRedrawQueued = false;
-            return true;
-        }
-
-        if ((hasModFiles || hasManip) && (_forceFullReapply || _needsCollectionRebuild))
-        {
-            _explicitRedrawQueued = false;
-            return true;
-        }
-
-        return false;
-    }
 
     private static Dictionary<ObjectKind, HashSet<PlayerChanges>> BuildFullChangeSet(CharacterData characterData)
     {
@@ -1265,6 +1412,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     }
 
     private Task? _pairDownloadTask;
+    private Task _visibilityGraceTask;
 
     private async Task DownloadAndApplyCharacterAsync(Guid applicationBase, CharacterData charaData, Dictionary<ObjectKind, HashSet<PlayerChanges>> updatedData,
         bool updateModdedPaths, bool updateManip, Dictionary<(string GamePath, string? Hash), string>? cachedModdedPaths, CancellationToken downloadToken)
@@ -1275,6 +1423,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             bool skipDownscaleForPair = ShouldSkipDownscale();
             var user = GetPrimaryUserData();
             Dictionary<(string GamePath, string? Hash), string> moddedPaths;
+            List<FileReplacementData> missingReplacements = [];
 
             if (updateModdedPaths)
             {
@@ -1286,6 +1435,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                 {
                     int attempts = 0;
                     List<FileReplacementData> toDownloadReplacements = TryCalculateModdedDictionary(applicationBase, charaData, out moddedPaths, downloadToken);
+                    missingReplacements = toDownloadReplacements;
 
                     while (toDownloadReplacements.Count > 0 && attempts++ <= 10 && !downloadToken.IsCancellationRequested)
                     {
@@ -1335,6 +1485,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                         }
 
                         toDownloadReplacements = TryCalculateModdedDictionary(applicationBase, charaData, out moddedPaths, downloadToken);
+                        missingReplacements = toDownloadReplacements;
 
                         if (toDownloadReplacements.TrueForAll(c => _downloadManager.ForbiddenTransfers.Exists(f => string.Equals(f.Hash, c.Hash, StringComparison.Ordinal))))
                         {
@@ -1358,6 +1509,54 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                     : [];
             }
 
+            var wantsModApply = updateModdedPaths || updateManip;
+            var pendingModReapply = false;
+            var deferModApply = false;
+
+            if (wantsModApply && missingReplacements.Count > 0)
+            {
+                CountMissingReplacements(missingReplacements, out var missingCritical, out var missingNonCritical, out var missingForbidden);
+                _lastMissingCriticalMods = missingCritical;
+                _lastMissingNonCriticalMods = missingNonCritical;
+                _lastMissingForbiddenMods = missingForbidden;
+
+                var hasCriticalMissing = missingCritical > 0;
+                var hasNonCriticalMissing = missingNonCritical > 0;
+                var hasDownloadableMissing = missingReplacements.Any(replacement => !IsForbiddenHash(replacement.Hash));
+                var hasDownloadableCriticalMissing = hasCriticalMissing
+                    && missingReplacements.Any(replacement => !IsForbiddenHash(replacement.Hash) && IsCriticalModReplacement(replacement));
+
+                pendingModReapply = hasDownloadableMissing;
+                _lastModApplyDeferred = false;
+
+                if (hasDownloadableCriticalMissing)
+                {
+                    deferModApply = true;
+                    _lastModApplyDeferred = true;
+                    Logger.LogDebug("[BASE-{appBase}] Critical mod files missing for {handler}, deferring mod apply ({count} missing)",
+                        applicationBase, GetLogIdentifier(), missingReplacements.Count);
+                }
+                else if (hasNonCriticalMissing && hasDownloadableMissing)
+                {
+                    Logger.LogDebug("[BASE-{appBase}] Non-critical mod files missing for {handler}, applying partial mods and reapplying after downloads ({count} missing)",
+                        applicationBase, GetLogIdentifier(), missingReplacements.Count);
+                }
+            }
+            else
+            {
+                _lastMissingCriticalMods = 0;
+                _lastMissingNonCriticalMods = 0;
+                _lastMissingForbiddenMods = 0;
+                _lastModApplyDeferred = false;
+            }
+
+            if (deferModApply)
+            {
+                updateModdedPaths = false;
+                updateManip = false;
+                RemoveModApplyChanges(updatedData);
+            }
+
             downloadToken.ThrowIfCancellationRequested();
 
             var handlerForApply = _charaHandler;
@@ -1390,7 +1589,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
             _applicationCancellationTokenSource = _applicationCancellationTokenSource.CancelRecreate() ?? new CancellationTokenSource();
             var token = _applicationCancellationTokenSource.Token;
 
-            _applicationTask = ApplyCharacterDataAsync(applicationBase, handlerForApply, charaData, updatedData, updateModdedPaths, updateManip, moddedPaths, token);
+            _applicationTask = ApplyCharacterDataAsync(applicationBase, handlerForApply, charaData, updatedData, updateModdedPaths, updateManip, moddedPaths, wantsModApply, pendingModReapply, token);
         }
         finally
         {
@@ -1399,7 +1598,7 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
     }
 
     private async Task ApplyCharacterDataAsync(Guid applicationBase, GameObjectHandler handlerForApply, CharacterData charaData, Dictionary<ObjectKind, HashSet<PlayerChanges>> updatedData, bool updateModdedPaths, bool updateManip,
-        Dictionary<(string GamePath, string? Hash), string> moddedPaths, CancellationToken token)
+        Dictionary<(string GamePath, string? Hash), string> moddedPaths, bool wantsModApply, bool pendingModReapply, CancellationToken token)
     {
         try
         {
@@ -1408,6 +1607,10 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
 
             Logger.LogDebug("[{applicationId}] Waiting for initial draw for for {handler}", _applicationId, handlerForApply);
             await _dalamudUtil.WaitWhileCharacterIsDrawing(Logger, handlerForApply, _applicationId, 30000, token).ConfigureAwait(false);
+            if (handlerForApply.Address != nint.Zero)
+            {
+                await _actorObjectService.WaitForFullyLoadedAsync(handlerForApply.Address, token).ConfigureAwait(false);
+            }
 
             token.ThrowIfCancellationRequested();
 
@@ -1474,7 +1677,11 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
 
             _cachedData = charaData;
             _pairStateCache.Store(Ident, charaData);
-            _forceFullReapply = false;
+            if (wantsModApply)
+            {
+                _pendingModReapply = pendingModReapply;
+            }
+            _forceFullReapply = _pendingModReapply;
             _needsCollectionRebuild = false;
             if (LastAppliedApproximateVRAMBytes < 0 || LastAppliedApproximateEffectiveVRAMBytes < 0)
             {
@@ -1520,8 +1727,15 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
 
     private void FrameworkUpdate()
     {
-        if (string.IsNullOrEmpty(PlayerName))
+        if (string.IsNullOrEmpty(PlayerName) && _charaHandler is null)
         {
+            var now = DateTime.UtcNow;
+            if (now < _nextActorLookupUtc)
+            {
+                return;
+            }
+
+            _nextActorLookupUtc = now + ActorLookupInterval;
             var pc = _dalamudUtil.FindPlayerByNameHash(Ident);
             if (pc == default((string, nint))) return;
             Logger.LogDebug("One-Time Initializing {handler}", GetLogIdentifier());
@@ -1531,6 +1745,11 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
                 $"Initializing User For Character {pc.Name}")));
         }
 
+        TryHandleVisibilityUpdate();
+    }
+
+    private void TryHandleVisibilityUpdate()
+    {
         if (_charaHandler?.Address != nint.Zero && !IsVisible && !_pauseRequested)
         {
             Guid appData = Guid.NewGuid();
@@ -1577,16 +1796,24 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
         else if (_charaHandler?.Address == nint.Zero && IsVisible)
         {
-            IsVisible = false;
+            HandleVisibilityLoss(logChange: true);
-            _charaHandler.Invalidate();
-            _downloadCancellationTokenSource?.CancelDispose();
-            _downloadCancellationTokenSource = null;
-            Logger.LogTrace("{handler} visibility changed, now: {visi}", GetLogIdentifier(), IsVisible);
         }
 
         TryApplyQueuedData();
     }
 
+    private void HandleVisibilityLoss(bool logChange)
+    {
+        IsVisible = false;
+        _charaHandler?.Invalidate();
+        _downloadCancellationTokenSource?.CancelDispose();
+        _downloadCancellationTokenSource = null;
+        if (logChange)
+        {
+            Logger.LogTrace("{handler} visibility changed, now: {visi}", GetLogIdentifier(), IsVisible);
+        }
+    }
+
     private void Initialize(string name)
     {
         PlayerName = name;
@@ -1913,7 +2140,164 @@ internal sealed class PairHandlerAdapter : DisposableMediatorSubscriberBase, IPa
         }
 
         _dataReceivedInDowntime = null;
-        ApplyCharacterData(pending.ApplicationId,
+        _ = Task.Run(() =>
-            pending.CharacterData, pending.Forced);
+        {
+            try
+            {
+                ApplyCharacterData(pending.ApplicationId, pending.CharacterData, pending.Forced);
+            }
+            catch (Exception ex)
+        {
+            Logger.LogError(ex, "Failed applying queued data for {handler}", GetLogIdentifier());
+        }
+    });
+    }
+
+    private void HandleActorTracked(ActorObjectService.ActorDescriptor descriptor)
+    {
+        if (!TryResolveDescriptorHash(descriptor, out var hashedCid))
+            return;
+
+        if (!string.Equals(hashedCid, Ident, StringComparison.Ordinal))
+            return;
+
+        if (descriptor.Address == nint.Zero)
+            return;
+
+        RefreshTrackedHandler(descriptor);
+        QueueActorInitialization(descriptor);
+    }
+
+    private void QueueActorInitialization(ActorObjectService.ActorDescriptor descriptor)
+    {
+        lock (_actorInitializationGate)
+        {
+            _pendingActorDescriptor = descriptor;
+            if (_actorInitializationInProgress)
+            {
+                return;
+            }
+
+            _actorInitializationInProgress = true;
+        }
+
+        _ = Task.Run(InitializeFromTrackedAsync);
+    }
+
+    private async Task InitializeFromTrackedAsync()
+    {
+        try
+        {
+            await ActorInitializationLimiter.WaitAsync().ConfigureAwait(false);
+            while (true)
+            {
+                ActorObjectService.ActorDescriptor? descriptor;
+                lock (_actorInitializationGate)
+                {
+                    descriptor = _pendingActorDescriptor;
+                    _pendingActorDescriptor = null;
+                }
+
+                if (!descriptor.HasValue)
+                {
+                    break;
+                }
+
+                if (_frameworkUpdateSubscribed && _actorObjectService.HooksActive)
+                {
+                    Mediator.Unsubscribe<FrameworkUpdateMessage>(this);
+                    _frameworkUpdateSubscribed = false;
+                }
+
+                if (string.IsNullOrEmpty(PlayerName) || _charaHandler is null)
+                {
+                    Logger.LogDebug("Actor tracked for {handler}, initializing from hook", GetLogIdentifier());
+                    Initialize(descriptor.Value.Name);
+                    Mediator.Publish(new EventMessage(new Event(PlayerName, GetPrimaryUserData(), nameof(PairHandlerAdapter), EventSeverity.Informational,
+                        $"Initializing User For Character {descriptor.Value.Name}")));
+                }
+
+                RefreshTrackedHandler(descriptor.Value);
+                TryHandleVisibilityUpdate();
+            }
+        }
+        finally
+        {
+            ActorInitializationLimiter.Release();
+            lock (_actorInitializationGate)
+            {
+                _actorInitializationInProgress = false;
+                if (_pendingActorDescriptor.HasValue)
+                {
+                    _actorInitializationInProgress = true;
+                    _ = Task.Run(InitializeFromTrackedAsync);
+                }
+            }
+        }
+    }
+
+    private void RefreshTrackedHandler(ActorObjectService.ActorDescriptor descriptor)
+    {
+        if (_charaHandler is null)
+            return;
+
+        if (descriptor.Address == nint.Zero)
+            return;
+
+        if (_charaHandler.Address == descriptor.Address)
+            return;
+
+        _charaHandler.Refresh();
+    }
+
+    private void HandleActorUntracked(ActorObjectService.ActorDescriptor descriptor)
+    {
+        if (!TryResolveDescriptorHash(descriptor, out var hashedCid))
+        {
+            if (_charaHandler is null || _charaHandler.Address == nint.Zero)
+                return;
+
+            if (descriptor.Address != _charaHandler.Address)
+                return;
+        }
+        else if (!string.Equals(hashedCid, Ident, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        if (_charaHandler is null || _charaHandler.Address == nint.Zero)
+            return;
+
+        if (descriptor.Address != _charaHandler.Address)
+            return;
+
+        HandleVisibilityLoss(logChange: false);
+    }
+
+    private bool TryResolveDescriptorHash(ActorObjectService.ActorDescriptor descriptor, out string hashedCid)
+    {
+        hashedCid = descriptor.HashedContentId ?? string.Empty;
+        if (!string.IsNullOrEmpty(hashedCid))
+            return true;
+
+        if (descriptor.ObjectKind != DalamudObjectKind.Player || descriptor.Address == nint.Zero)
+            return false;
+
+        hashedCid = DalamudUtilService.GetHashedCIDFromPlayerPointer(descriptor.Address);
+        return !string.IsNullOrEmpty(hashedCid);
+    }
+
+    private async Task ApplyCustomizeAsync(nint address, string customizeData, ObjectKind kind)
+    {
+        _customizeIds[kind] = await _ipcManager.CustomizePlus.SetBodyScaleAsync(address, customizeData).ConfigureAwait(false);
+    }
+
+    private async Task RevertCustomizeAsync(Guid? customizeId, ObjectKind kind)
+    {
+        if (!customizeId.HasValue)
+            return;
+
+        await _ipcManager.CustomizePlus.RevertByIdAsync(customizeId.Value).ConfigureAwait(false);
+        _customizeIds.Remove(kind);
     }
 }

LightlessSync/PlayerData/Pairs/PairHandlerAdapterFactory.cs

@@ -2,6 +2,7 @@ using LightlessSync.FileCache;
 using LightlessSync.Interop.Ipc;
 using LightlessSync.PlayerData.Factories;
 using LightlessSync.Services;
+using LightlessSync.Services.ActorTracking;
 using LightlessSync.Services.Mediator;
 using LightlessSync.Services.PairProcessing;
 using LightlessSync.Services.ServerConfiguration;
@@ -71,6 +72,7 @@ internal sealed class PairHandlerAdapterFactory : IPairHandlerAdapterFactory
     {
         var downloadManager = _fileDownloadManagerFactory.Create();
         var dalamudUtilService = _serviceProvider.GetRequiredService<DalamudUtilService>();
+        var actorObjectService = _serviceProvider.GetRequiredService<ActorObjectService>();
         return new PairHandlerAdapter(
             _loggerFactory.CreateLogger<PairHandlerAdapter>(),
             _mediator,
@@ -81,6 +83,7 @@ internal sealed class PairHandlerAdapterFactory : IPairHandlerAdapterFactory
             downloadManager,
             _pluginWarningNotificationManager,
             dalamudUtilService,
+            actorObjectService,
             _lifetime,
             _fileCacheManager,
             _playerPerformanceService,

LightlessSync/PlayerData/Pairs/PairHandlerRegistry.cs

@@ -11,7 +11,9 @@ public sealed class PairHandlerRegistry : IDisposable
 {
     private readonly object _gate = new();
     private readonly object _pendingGate = new();
+    private readonly object _visibilityGate = new();
     private readonly Dictionary<string, PairHandlerEntry> _entriesByIdent = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, CancellationTokenSource> _pendingInvisibleEvictions = new(StringComparer.Ordinal);
     private readonly Dictionary<IPairHandlerAdapter, PairHandlerEntry> _entriesByHandler = new(ReferenceEqualityComparer.Instance);
 
     private readonly IPairHandlerAdapterFactory _handlerFactory;
@@ -144,6 +146,37 @@ public sealed class PairHandlerRegistry : IDisposable
         return PairOperationResult<PairUniqueIdentifier>.Ok(registration.PairIdent);
     }
 
+    private PairOperationResult CancelAllInvisibleEvictions()
+    {
+        List<CancellationTokenSource> snapshot;
+        lock (_visibilityGate)
+        {
+            snapshot = [.. _pendingInvisibleEvictions.Values];
+            _pendingInvisibleEvictions.Clear();
+        }
+
+        List<string>? errors = null;
+
+        foreach (var cts in snapshot)
+        {
+            try { cts.Cancel(); }
+            catch (Exception ex)
+            {
+                (errors ??= new List<string>()).Add($"Cancel: {ex.Message}");
+            }
+
+            try { cts.Dispose(); }
+            catch (Exception ex)
+            {
+                (errors ??= new List<string>()).Add($"Dispose: {ex.Message}");
+            }
+        }
+
+        return errors is null
+            ? PairOperationResult.Ok()
+            : PairOperationResult.Fail($"CancelAllInvisibleEvictions had error(s): {string.Join(" | ", errors)}");
+    }
+
     public PairOperationResult ApplyCharacterData(PairRegistration registration, OnlineUserCharaDataDto dto)
     {
         if (registration.CharacterIdent is null)
@@ -300,6 +333,7 @@ public sealed class PairHandlerRegistry : IDisposable
         lock (_gate)
         {
             handlers = _entriesByHandler.Keys.ToList();
+            CancelAllInvisibleEvictions();
             _entriesByIdent.Clear();
             _entriesByHandler.Clear();
         }
@@ -332,6 +366,7 @@ public sealed class PairHandlerRegistry : IDisposable
         lock (_gate)
         {
             handlers = _entriesByHandler.Keys.ToList();
+            CancelAllInvisibleEvictions();
             _entriesByIdent.Clear();
             _entriesByHandler.Clear();
         }

LightlessSync/Plugin.cs

@@ -201,6 +201,7 @@ public sealed class Plugin : IDalamudPlugin
             gameInteropProvider,
             objectTable,
             clientState,
+            condition,
             sp.GetRequiredService<LightlessMediator>()));
 
         services.AddSingleton(sp => new DalamudUtilService(
@@ -267,6 +268,7 @@ public sealed class Plugin : IDalamudPlugin
             sp.GetRequiredService<ILogger<LightFinderPlateHandler>>(),
             addonLifecycle,
             gameGui,
+            clientState,
             sp.GetRequiredService<LightlessConfigService>(),
             sp.GetRequiredService<LightlessMediator>(),
             objectTable,

LightlessSync/Services/ActorTracking/ActorObjectService.cs

@@ -1,4 +1,5 @@
 using System.Collections.Concurrent;
+using Dalamud.Game.ClientState.Conditions;
 using Dalamud.Game.ClientState.Objects.SubKinds;
 using Dalamud.Hooking;
 using Dalamud.Plugin.Services;
@@ -31,13 +32,18 @@ public sealed class ActorObjectService : IHostedService, IDisposable
     private readonly IFramework _framework;
     private readonly IGameInteropProvider _interop;
     private readonly IObjectTable _objectTable;
+    private readonly IClientState _clientState;
+    private readonly ICondition _condition;
     private readonly LightlessMediator _mediator;
 
     private readonly ConcurrentDictionary<nint, ActorDescriptor> _activePlayers = new();
+    private readonly ConcurrentDictionary<nint, ActorDescriptor> _gposePlayers = new();
     private readonly ConcurrentDictionary<string, ActorDescriptor> _actorsByHash = new(StringComparer.Ordinal);
     private readonly ConcurrentDictionary<string, ConcurrentDictionary<nint, ActorDescriptor>> _actorsByName = new(StringComparer.Ordinal);
+    private readonly ConcurrentDictionary<nint, byte> _pendingHashResolutions = new();
     private readonly OwnedObjectTracker _ownedTracker = new();
     private ActorSnapshot _snapshot = ActorSnapshot.Empty;
+    private GposeSnapshot _gposeSnapshot = GposeSnapshot.Empty;
 
     private Hook<Character.Delegates.OnInitialize>? _onInitializeHook;
     private Hook<Character.Delegates.Terminate>? _onTerminateHook;
@@ -55,21 +61,29 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         IGameInteropProvider interop,
         IObjectTable objectTable,
         IClientState clientState,
+        ICondition condition,
         LightlessMediator mediator)
     {
         _logger = logger;
         _framework = framework;
         _interop = interop;
         _objectTable = objectTable;
+        _clientState = clientState;
+        _condition = condition;
         _mediator = mediator;
     }
 
+    private bool IsZoning => _condition[ConditionFlag.BetweenAreas] || _condition[ConditionFlag.BetweenAreas51];
+
     private ActorSnapshot Snapshot => Volatile.Read(ref _snapshot);
+    private GposeSnapshot CurrentGposeSnapshot => Volatile.Read(ref _gposeSnapshot);
 
     public IReadOnlyList<nint> PlayerAddresses => Snapshot.PlayerAddresses;
 
-    public IEnumerable<ActorDescriptor> PlayerDescriptors => _activePlayers.Values;
+    public IEnumerable<ActorDescriptor> ObjectDescriptors => _activePlayers.Values;
-    public IReadOnlyList<ActorDescriptor> PlayerCharacterDescriptors => Snapshot.PlayerDescriptors;
+    public IReadOnlyList<ActorDescriptor> PlayerDescriptors => Snapshot.PlayerDescriptors;
+    public IReadOnlyList<ActorDescriptor> OwnedDescriptors => Snapshot.OwnedDescriptors;
+    public IReadOnlyList<ActorDescriptor> GposeDescriptors => CurrentGposeSnapshot.GposeDescriptors;
 
     public bool TryGetActorByHash(string hash, out ActorDescriptor descriptor) => _actorsByHash.TryGetValue(hash, out descriptor);
     public bool TryGetValidatedActorByHash(string hash, out ActorDescriptor descriptor)
@@ -113,6 +127,7 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         return false;
     }
     public bool HooksActive => _hooksActive;
+    public bool HasPendingHashResolutions => !_pendingHashResolutions.IsEmpty;
     public IReadOnlyList<nint> RenderedPlayerAddresses => Snapshot.OwnedObjects.RenderedPlayers;
     public IReadOnlyList<nint> RenderedCompanionAddresses => Snapshot.OwnedObjects.RenderedCompanions;
     public IReadOnlyList<nint> OwnedObjectAddresses => Snapshot.OwnedObjects.OwnedAddresses;
@@ -207,7 +222,7 @@ public sealed class ActorObjectService : IHostedService, IDisposable
             cancellationToken.ThrowIfCancellationRequested();
 
             var isLoaded = await _framework.RunOnFrameworkThread(() => IsObjectFullyLoaded(address)).ConfigureAwait(false);
-            if (isLoaded)
+            if (!IsZoning && isLoaded)
                 return;
 
             await Task.Delay(100, cancellationToken).ConfigureAwait(false);
@@ -297,10 +312,13 @@ public sealed class ActorObjectService : IHostedService, IDisposable
     {
         DisposeHooks();
         _activePlayers.Clear();
+        _gposePlayers.Clear();
         _actorsByHash.Clear();
         _actorsByName.Clear();
+        _pendingHashResolutions.Clear();
         _ownedTracker.Reset();
         Volatile.Write(ref _snapshot, ActorSnapshot.Empty);
+        Volatile.Write(ref _gposeSnapshot, GposeSnapshot.Empty);
         return Task.CompletedTask;
     }
 
@@ -336,7 +354,7 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         _onCompanionTerminateHook.Enable();
 
         _hooksActive = true;
-        _logger.LogDebug("ActorObjectService hooks enabled.");
+        _logger.LogTrace("ActorObjectService hooks enabled.");
     }
 
     private Task WarmupExistingActors()
@@ -350,36 +368,21 @@ public sealed class ActorObjectService : IHostedService, IDisposable
 
     private unsafe void OnCharacterInitialized(Character* chara)
     {
-        try
+        ExecuteOriginal(() => _onInitializeHook!.Original(chara), "Error invoking original character initialize.");
-        {
+        QueueTrack((GameObject*)chara);
-            _onInitializeHook!.Original(chara);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error invoking original character initialize.");
-        }
-
-        QueueFrameworkUpdate(() => TrackGameObject((GameObject*)chara));
     }
 
     private unsafe void OnCharacterTerminated(Character* chara)
     {
         var address = (nint)chara;
-        QueueFrameworkUpdate(() => UntrackGameObject(address));
+        QueueUntrack(address);
-        try
+        ExecuteOriginal(() => _onTerminateHook!.Original(chara), "Error invoking original character terminate.");
-        {
-            _onTerminateHook!.Original(chara);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error invoking original character terminate.");
-        }
     }
 
     private unsafe GameObject* OnCharacterDisposed(Character* chara, byte freeMemory)
     {
         var address = (nint)chara;
-        QueueFrameworkUpdate(() => UntrackGameObject(address));
+        QueueUntrack(address);
         try
         {
             return _onDestructorHook!.Original(chara, freeMemory);
@@ -416,7 +419,7 @@ public sealed class ActorObjectService : IHostedService, IDisposable
 
         if (_logger.IsEnabled(LogLevel.Debug))
         {
-            _logger.LogDebug("Actor tracked: {Name} addr={Address:X} idx={Index} owned={OwnedKind} local={Local} gpose={Gpose}",
+            _logger.LogTrace("Actor tracked: {Name} addr={Address:X} idx={Index} owned={OwnedKind} local={Local} gpose={Gpose}",
                 descriptor.Name,
                 descriptor.Address,
                 descriptor.ObjectIndex,
@@ -534,7 +537,7 @@ public sealed class ActorObjectService : IHostedService, IDisposable
             RemoveDescriptor(descriptor);
             if (_logger.IsEnabled(LogLevel.Debug))
             {
-                _logger.LogDebug("Actor untracked: {Name} addr={Address:X} idx={Index} owned={OwnedKind}",
+                _logger.LogTrace("Actor untracked: {Name} addr={Address:X} idx={Index} owned={OwnedKind}",
                     descriptor.Name,
                     descriptor.Address,
                     descriptor.ObjectIndex,
@@ -558,10 +561,14 @@ public sealed class ActorObjectService : IHostedService, IDisposable
             if (!seen.Add(address))
                 continue;
 
-            if (_activePlayers.ContainsKey(address))
+            var gameObject = (GameObject*)address;
+            if (_activePlayers.TryGetValue(address, out var existing))
+            {
+                RefreshDescriptorIfNeeded(existing, gameObject);
                 continue;
+            }
 
-            TrackGameObject((GameObject*)address);
+            TrackGameObject(gameObject);
         }
 
         var stale = _activePlayers.Keys.Where(addr => !seen.Contains(addr)).ToList();
@@ -574,6 +581,50 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         {
             _nextRefreshAllowed = DateTime.UtcNow + SnapshotRefreshInterval;
         }
+
+        if (_clientState.IsGPosing)
+        {
+            RefreshGposeActorsInternal();
+        }
+        else if (!_gposePlayers.IsEmpty)
+        {
+            _gposePlayers.Clear();
+            PublishGposeSnapshot();
+        }
+    }
+
+    private unsafe void RefreshDescriptorIfNeeded(ActorDescriptor existing, GameObject* gameObject)
+    {
+        if (gameObject == null)
+            return;
+
+        if (existing.ObjectKind != DalamudObjectKind.Player || !string.IsNullOrEmpty(existing.HashedContentId))
+            return;
+
+        var objectKind = (DalamudObjectKind)gameObject->ObjectKind;
+        if (!IsSupportedObjectKind(objectKind))
+            return;
+
+        if (BuildDescriptor(gameObject, objectKind) is not { } updated)
+            return;
+
+        if (string.IsNullOrEmpty(updated.HashedContentId))
+            return;
+
+        ReplaceDescriptor(existing, updated);
+        _mediator.Publish(new ActorTrackedMessage(updated));
+    }
+
+    private void ReplaceDescriptor(ActorDescriptor existing, ActorDescriptor updated)
+    {
+        RemoveDescriptorFromIndexes(existing);
+        _ownedTracker.OnDescriptorRemoved(existing);
+
+        _activePlayers[updated.Address] = updated;
+        IndexDescriptor(updated);
+        _ownedTracker.OnDescriptorAdded(updated);
+        UpdatePendingHashResolutions(updated);
+        PublishSnapshot();
     }
 
     private void IndexDescriptor(ActorDescriptor descriptor)
@@ -605,30 +656,15 @@ public sealed class ActorObjectService : IHostedService, IDisposable
 
     private unsafe void OnCompanionInitialized(Companion* companion)
     {
-        try
+        ExecuteOriginal(() => _onCompanionInitializeHook!.Original(companion), "Error invoking original companion initialize.");
-        {
+        QueueTrack((GameObject*)companion);
-            _onCompanionInitializeHook!.Original(companion);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error invoking original companion initialize.");
-        }
-
-        QueueFrameworkUpdate(() => TrackGameObject((GameObject*)companion));
     }
 
     private unsafe void OnCompanionTerminated(Companion* companion)
     {
         var address = (nint)companion;
-        QueueFrameworkUpdate(() => UntrackGameObject(address));
+        QueueUntrack(address);
-        try
+        ExecuteOriginal(() => _onCompanionTerminateHook!.Original(companion), "Error invoking original companion terminate.");
-        {
-            _onCompanionTerminateHook!.Original(companion);
-        }
-        catch (Exception ex)
-        {
-            _logger.LogError(ex, "Error invoking original companion terminate.");
-        }
     }
 
     private void RemoveDescriptorFromIndexes(ActorDescriptor descriptor)
@@ -655,6 +691,7 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         _activePlayers[descriptor.Address] = descriptor;
         IndexDescriptor(descriptor);
         _ownedTracker.OnDescriptorAdded(descriptor);
+        UpdatePendingHashResolutions(descriptor);
         PublishSnapshot();
     }
 
@@ -662,21 +699,42 @@ public sealed class ActorObjectService : IHostedService, IDisposable
     {
         RemoveDescriptorFromIndexes(descriptor);
         _ownedTracker.OnDescriptorRemoved(descriptor);
+        _pendingHashResolutions.TryRemove(descriptor.Address, out _);
         PublishSnapshot();
     }
 
+    private void UpdatePendingHashResolutions(ActorDescriptor descriptor)
+    {
+        if (descriptor.ObjectKind != DalamudObjectKind.Player)
+        {
+            _pendingHashResolutions.TryRemove(descriptor.Address, out _);
+            return;
+        }
+
+        if (string.IsNullOrEmpty(descriptor.HashedContentId))
+        {
+            _pendingHashResolutions[descriptor.Address] = 1;
+            return;
+        }
+
+        _pendingHashResolutions.TryRemove(descriptor.Address, out _);
+    }
+
     private void PublishSnapshot()
     {
         var playerDescriptors = _activePlayers.Values
             .Where(descriptor => descriptor.ObjectKind == DalamudObjectKind.Player)
             .ToArray();
+        var ownedDescriptors = _activePlayers.Values
+            .Where(descriptor => descriptor.OwnedKind is not null)
+            .ToArray();
         var playerAddresses = new nint[playerDescriptors.Length];
         for (var i = 0; i < playerDescriptors.Length; i++)
             playerAddresses[i] = playerDescriptors[i].Address;
 
         var ownedSnapshot = _ownedTracker.CreateSnapshot();
         var nextGeneration = Snapshot.Generation + 1;
-        var snapshot = new ActorSnapshot(playerDescriptors, playerAddresses, ownedSnapshot, nextGeneration);
+        var snapshot = new ActorSnapshot(playerDescriptors, ownedDescriptors, playerAddresses, ownedSnapshot, nextGeneration);
         Volatile.Write(ref _snapshot, snapshot);
     }
 
@@ -694,6 +752,24 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         _ = _framework.RunOnFrameworkThread(action);
     }
 
+    private void ExecuteOriginal(Action action, string errorMessage)
+    {
+        try
+        {
+            action();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, errorMessage);
+        }
+    }
+
+    private unsafe void QueueTrack(GameObject* gameObject)
+        => QueueFrameworkUpdate(() => TrackGameObject(gameObject));
+
+    private void QueueUntrack(nint address)
+        => QueueFrameworkUpdate(() => UntrackGameObject(address));
+
     private void DisposeHooks()
     {
         var hadHooks = _hooksActive
@@ -725,7 +801,7 @@ public sealed class ActorObjectService : IHostedService, IDisposable
 
         if (hadHooks)
         {
-            _logger.LogDebug("ActorObjectService hooks disabled.");
+            _logger.LogTrace("ActorObjectService hooks disabled.");
         }
     }
 
@@ -770,6 +846,89 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         return results;
     }
 
+    private unsafe void RefreshGposeActorsInternal()
+    {
+        var addresses = EnumerateGposeCharacterAddresses();
+        HashSet<nint> seen = new(addresses.Count);
+
+        foreach (var address in addresses)
+        {
+            if (address == nint.Zero)
+                continue;
+
+            if (!seen.Add(address))
+                continue;
+
+            if (_gposePlayers.ContainsKey(address))
+                continue;
+
+            TrackGposeObject((GameObject*)address);
+        }
+
+        var stale = _gposePlayers.Keys.Where(addr => !seen.Contains(addr)).ToList();
+        foreach (var staleAddress in stale)
+        {
+            UntrackGposeObject(staleAddress);
+        }
+
+        PublishGposeSnapshot();
+    }
+
+    private unsafe void TrackGposeObject(GameObject* gameObject)
+    {
+        if (gameObject == null)
+            return;
+
+        var objectKind = (DalamudObjectKind)gameObject->ObjectKind;
+        if (objectKind != DalamudObjectKind.Player)
+            return;
+
+        if (BuildDescriptor(gameObject, objectKind) is not { } descriptor)
+            return;
+
+        if (!descriptor.IsInGpose)
+            return;
+
+        _gposePlayers[descriptor.Address] = descriptor;
+    }
+
+    private void UntrackGposeObject(nint address)
+    {
+        if (address == nint.Zero)
+            return;
+
+        _gposePlayers.TryRemove(address, out _);
+    }
+
+    private void PublishGposeSnapshot()
+    {
+        var gposeDescriptors = _gposePlayers.Values.ToArray();
+        var gposeAddresses = new nint[gposeDescriptors.Length];
+        for (var i = 0; i < gposeDescriptors.Length; i++)
+            gposeAddresses[i] = gposeDescriptors[i].Address;
+
+        var nextGeneration = CurrentGposeSnapshot.Generation + 1;
+        var snapshot = new GposeSnapshot(gposeDescriptors, gposeAddresses, nextGeneration);
+        Volatile.Write(ref _gposeSnapshot, snapshot);
+    }
+
+    private List<nint> EnumerateGposeCharacterAddresses()
+    {
+        var results = new List<nint>(16);
+        foreach (var obj in _objectTable)
+        {
+            if (obj.ObjectKind != DalamudObjectKind.Player)
+                continue;
+
+            if (obj.ObjectIndex < 200)
+                continue;
+
+            results.Add(obj.Address);
+        }
+
+        return results;
+    }
+
     private static unsafe bool IsObjectFullyLoaded(nint address)
     {
         if (address == nint.Zero)
@@ -783,13 +942,10 @@ public sealed class ActorObjectService : IHostedService, IDisposable
         if (drawObject == null)
             return false;
 
-        if ((gameObject->RenderFlags & VisibilityFlags.Nameplate) != VisibilityFlags.None)
+        if ((ulong)gameObject->RenderFlags == 2048)
             return false;
 
         var characterBase = (CharacterBase*)drawObject;
-        if (characterBase == null)
-            return false;
-
         if (characterBase->HasModelInSlotLoaded != 0)
             return false;
 
@@ -925,14 +1081,27 @@ public sealed class ActorObjectService : IHostedService, IDisposable
 
     private sealed record ActorSnapshot(
         IReadOnlyList<ActorDescriptor> PlayerDescriptors,
+        IReadOnlyList<ActorDescriptor> OwnedDescriptors,
         IReadOnlyList<nint> PlayerAddresses,
         OwnedObjectSnapshot OwnedObjects,
         int Generation)
     {
         public static ActorSnapshot Empty { get; } = new(
+            Array.Empty<ActorDescriptor>(),
             Array.Empty<ActorDescriptor>(),
             Array.Empty<nint>(),
             OwnedObjectSnapshot.Empty,
             0);
     }
+
+    private sealed record GposeSnapshot(
+        IReadOnlyList<ActorDescriptor> GposeDescriptors,
+        IReadOnlyList<nint> GposeAddresses,
+        int Generation)
+    {
+        public static GposeSnapshot Empty { get; } = new(
+            Array.Empty<ActorDescriptor>(),
+            Array.Empty<nint>(),
+            0);
+    }
 }

LightlessSync/Services/Chat/ZoneChatService.cs

@@ -1,4 +1,5 @@
 using LightlessSync.API.Dto.Chat;
+using LightlessSync.API.Data.Extensions;
 using LightlessSync.Services.ActorTracking;
 using LightlessSync.Services.Mediator;
 using LightlessSync.WebAPI;
@@ -36,6 +37,8 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
     private readonly Dictionary<string, bool> _lastPresenceStates = new(StringComparer.Ordinal);
     private readonly Dictionary<string, string> _selfTokens = new(StringComparer.Ordinal);
     private readonly List<PendingSelfMessage> _pendingSelfMessages = new();
+    private List<ChatChannelSnapshot>? _cachedChannelSnapshots;
+    private bool _channelsSnapshotDirty = true;
 
     private bool _isLoggedIn;
     private bool _isConnected;
@@ -69,6 +72,11 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
     {
         using (_sync.EnterScope())
         {
+            if (!_channelsSnapshotDirty && _cachedChannelSnapshots is not null)
+            {
+                return _cachedChannelSnapshots;
+            }
+
             var snapshots = new List<ChatChannelSnapshot>(_channelOrder.Count);
             foreach (var key in _channelOrder)
             {
@@ -98,6 +106,8 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
                     state.Messages.ToList()));
             }
 
+            _cachedChannelSnapshots = snapshots;
+            _channelsSnapshotDirty = false;
             return snapshots;
         }
     }
@@ -135,6 +145,8 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
                 state.UnreadCount = 0;
                 _lastReadCounts[key] = state.Messages.Count;
             }
+
+            MarkChannelsSnapshotDirtyLocked();
         }
     }
 
@@ -186,6 +198,7 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
             if (!wasEnabled)
             {
                 _chatEnabled = true;
+                MarkChannelsSnapshotDirtyLocked();
             }
         }
 
@@ -231,6 +244,8 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
                 state.IsAvailable = false;
                 state.StatusText = "Chat services disabled";
             }
+
+            MarkChannelsSnapshotDirtyLocked();
         }
 
         UnregisterChatHandler();
@@ -717,7 +732,7 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
                 _zoneDefinitions[key] = new ZoneChannelDefinition(key, info.DisplayName ?? key, descriptor, territories);
             }
 
-            var territoryData = _dalamudUtilService.TerritoryData.Value;
+            var territoryData = _dalamudUtilService.TerritoryDataEnglish.Value;
             foreach (var kvp in territoryData)
             {
                 foreach (var variant in EnumerateTerritoryKeys(kvp.Value))
@@ -853,6 +868,12 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
         var infos = new List<GroupChatChannelInfoDto>(groups.Count);
         foreach (var group in groups)
         {
+            // basically prune the channel if it's disabled
+            if (group.GroupPermissions.IsDisableChat())
+            {
+                continue;
+            }
+
             var descriptor = new ChatChannelDescriptor
             {
                 Type = ChatChannelType.Group,
@@ -1023,6 +1044,8 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
                 state.UnreadCount = Math.Min(Math.Max(unreadFromHistory, incrementalUnread), MaxUnreadCount);
                 state.HasUnread = state.UnreadCount > 0;
             }
+
+            MarkChannelsSnapshotDirtyLocked();
         }
 
         Mediator.Publish(new ChatChannelMessageAdded(key, message));
@@ -1204,9 +1227,25 @@ public sealed class ZoneChatService : DisposableMediatorSubscriberBase, IHostedS
         {
             _activeChannelKey = _channelOrder.Count > 0 ? _channelOrder[0] : null;
         }
+
+        MarkChannelsSnapshotDirtyLocked();
     }
 
-    private void PublishChannelListChanged() => Mediator.Publish(new ChatChannelsUpdated());
+    private void MarkChannelsSnapshotDirty()
+    {
+        using (_sync.EnterScope())
+        {
+            _channelsSnapshotDirty = true;
+        }
+    }
+
+    private void MarkChannelsSnapshotDirtyLocked() => _channelsSnapshotDirty = true;
+
+    private void PublishChannelListChanged()
+    {
+        MarkChannelsSnapshotDirty();
+        Mediator.Publish(new ChatChannelsUpdated());
+    }
 
     private static IEnumerable<string> EnumerateTerritoryKeys(string? value)
     {

LightlessSync/Services/CommandManagerService.cs

@@ -49,7 +49,7 @@ public sealed class CommandManagerService : IDisposable
                 "\t /light analyze - Opens the Lightless Character Data Analysis window" + Environment.NewLine +
                 "\t /light settings - Opens the Lightless Settings window" + Environment.NewLine +
                 "\t /light finder - Opens the Lightfinder window" + Environment.NewLine +
-                "\t /light finder - Opens the Lightless Chat window"
+                "\t /light chat - Opens the Lightless Chat window"
         });
     }
 

LightlessSync/Services/ContextMenuService.cs

@@ -129,7 +129,6 @@ internal class ContextMenuService : IHostedService
 
         var snapshot = _pairUiService.GetSnapshot();
         var pair = snapshot.PairsByUid.Values.FirstOrDefault(p =>
-            p.IsVisible &&
             p.PlayerCharacterId != uint.MaxValue &&
             p.PlayerCharacterId == target.TargetObjectId);
 

LightlessSync/Services/DalamudUtilService.cs

@@ -91,43 +91,10 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
             return gameData.GetExcelSheet<ClassJob>(Dalamud.Game.ClientLanguage.English)!
                 .ToDictionary(k => k.RowId, k => k.NameEnglish.ToString());
         });
-        TerritoryData = new(() =>
+        var clientLanguage = _clientState.ClientLanguage;
-        {
+        TerritoryData = new(() => BuildTerritoryData(clientLanguage));
-            return gameData.GetExcelSheet<TerritoryType>(Dalamud.Game.ClientLanguage.English)!
+        TerritoryDataEnglish = new(() => BuildTerritoryData(Dalamud.Game.ClientLanguage.English));
-            .Where(w => w.RowId != 0)
+        MapData = new(() => BuildMapData(clientLanguage));
-            .ToDictionary(w => w.RowId, w =>
-            {
-                StringBuilder sb = new();
-                sb.Append(w.PlaceNameRegion.Value.Name);
-                if (w.PlaceName.ValueNullable != null)
-                {
-                    sb.Append(" - ");
-                    sb.Append(w.PlaceName.Value.Name);
-                }
-                return sb.ToString();
-            });
-        });
-        MapData = new(() =>
-        {
-            return gameData.GetExcelSheet<Map>(Dalamud.Game.ClientLanguage.English)!
-            .Where(w => w.RowId != 0)
-            .ToDictionary(w => w.RowId, w =>
-            {
-                StringBuilder sb = new();
-                sb.Append(w.PlaceNameRegion.Value.Name);
-                if (w.PlaceName.ValueNullable != null)
-                {
-                    sb.Append(" - ");
-                    sb.Append(w.PlaceName.Value.Name);
-                }
-                if (w.PlaceNameSub.ValueNullable != null && !string.IsNullOrEmpty(w.PlaceNameSub.Value.Name.ToString()))
-                {
-                    sb.Append(" - ");
-                    sb.Append(w.PlaceNameSub.Value.Name);
-                }
-                return (w, sb.ToString());
-            });
-        });
         mediator.Subscribe<TargetPairMessage>(this, (msg) =>
         {
             if (clientState.IsPvP) return;
@@ -158,6 +125,71 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
     private Lazy<ulong> RebuildCID() => new(GetCID);
 
     public bool IsWine { get; init; }
+    private Dictionary<uint, string> BuildTerritoryData(Dalamud.Game.ClientLanguage language)
+    {
+        var placeNames = _gameData.GetExcelSheet<PlaceName>(language)!;
+        return _gameData.GetExcelSheet<TerritoryType>(language)!
+            .Where(w => w.RowId != 0)
+            .ToDictionary(w => w.RowId, w =>
+            {
+                var regionName = GetPlaceName(placeNames, w.PlaceNameRegion.RowId);
+                var placeName = GetPlaceName(placeNames, w.PlaceName.RowId);
+                return BuildPlaceName(regionName, placeName, string.Empty);
+            });
+    }
+
+    private Dictionary<uint, (Map Map, string MapName)> BuildMapData(Dalamud.Game.ClientLanguage language)
+    {
+        var placeNames = _gameData.GetExcelSheet<PlaceName>(language)!;
+        return _gameData.GetExcelSheet<Map>(language)!
+            .Where(w => w.RowId != 0)
+            .ToDictionary(w => w.RowId, w =>
+            {
+                var regionName = GetPlaceName(placeNames, w.PlaceNameRegion.RowId);
+                var placeName = GetPlaceName(placeNames, w.PlaceName.RowId);
+                var subPlaceName = GetPlaceName(placeNames, w.PlaceNameSub.RowId);
+                var displayName = BuildPlaceName(regionName, placeName, subPlaceName);
+                return (w, displayName);
+            });
+    }
+    private static string GetPlaceName(Lumina.Excel.ExcelSheet<PlaceName> placeNames, uint rowId)
+    {
+        if (rowId == 0)
+        {
+            return string.Empty;
+        }
+
+        return placeNames.GetRow(rowId).Name.ToString();
+    }
+
+    private static string BuildPlaceName(string regionName, string placeName, string subPlaceName)
+    {
+        StringBuilder sb = new();
+        if (!string.IsNullOrWhiteSpace(regionName))
+        {
+            sb.Append(regionName);
+        }
+
+        if (!string.IsNullOrWhiteSpace(placeName))
+        {
+            if (sb.Length > 0)
+            {
+                sb.Append(" - ");
+            }
+            sb.Append(placeName);
+        }
+
+        if (!string.IsNullOrWhiteSpace(subPlaceName))
+        {
+            if (sb.Length > 0)
+            {
+                sb.Append(" - ");
+            }
+            sb.Append(subPlaceName);
+        }
+
+        return sb.ToString();
+    }
     private bool ResolvePairAddress(Pair pair, out Pair resolvedPair, out nint address)
     {
         resolvedPair = _pairFactory.Value.Create(pair.UniqueIdent) ?? pair;
@@ -245,6 +277,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
     public Lazy<Dictionary<uint, string>> JobData { get; private set; }
     public Lazy<Dictionary<ushort, string>> WorldData { get; private set; }
     public Lazy<Dictionary<uint, string>> TerritoryData { get; private set; }
+    public Lazy<Dictionary<uint, string>> TerritoryDataEnglish { get; private set; }
     public Lazy<Dictionary<uint, (Map Map, string MapName)>> MapData { get; private set; }
     public bool IsLodEnabled { get; private set; }
     public LightlessMediator Mediator { get; }
@@ -264,7 +297,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
                 return false;
             }
 
-            if (!TerritoryData.Value.TryGetValue(territoryId, out var name) || string.IsNullOrWhiteSpace(name))
+            if (!TerritoryDataEnglish.Value.TryGetValue(territoryId, out var name) || string.IsNullOrWhiteSpace(name))
             {
                 return false;
             }
@@ -327,8 +360,8 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
 
     public IEnumerable<ICharacter?> GetGposeCharactersFromObjectTable()
     {
-        foreach (var actor in _actorObjectService.PlayerDescriptors
+        foreach (var actor in _objectTable
-                     .Where(a => a.ObjectKind == DalamudObjectKind.Player && a.ObjectIndex > 200))
+                     .Where(a => a.ObjectIndex > 200 && a.ObjectKind == DalamudObjectKind.Player))
         {
             var character = _objectTable.CreateObjectReference(actor.Address) as ICharacter;
             if (character != null)
@@ -355,7 +388,8 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
 
         var playerAddress = playerPointer.Value;
         var ownerEntityId = ((Character*)playerAddress)->EntityId;
-        if (ownerEntityId == 0) return IntPtr.Zero;
+        var candidateAddress = _objectTable.GetObjectAddress(((GameObject*)playerAddress)->ObjectIndex + 1);
+        if (ownerEntityId == 0) return candidateAddress;
 
         if (playerAddress == _actorObjectService.LocalPlayerAddress)
         {
@@ -366,6 +400,17 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
             }
         }
 
+        if (candidateAddress != nint.Zero)
+        {
+            var candidate = (GameObject*)candidateAddress;
+            var candidateKind = (DalamudObjectKind)candidate->ObjectKind;
+            if ((candidateKind == DalamudObjectKind.MountType || candidateKind == DalamudObjectKind.Companion)
+                && ResolveOwnerId(candidate) == ownerEntityId)
+            {
+                return candidateAddress;
+            }
+        }
+
         var ownedObject = FindOwnedObject(ownerEntityId, playerAddress, static kind =>
             kind == DalamudObjectKind.MountType || kind == DalamudObjectKind.Companion);
         if (ownedObject != nint.Zero)
@@ -373,7 +418,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
             return ownedObject;
         }
 
-        return _objectTable.GetObjectAddress(((GameObject*)playerAddress)->ObjectIndex + 1);
+        return candidateAddress;
     }
 
     public async Task<IntPtr> GetMinionOrMountAsync(IntPtr? playerPointer = null)
@@ -490,6 +535,10 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
     {
         EnsureIsOnFramework();
         var playerChar = GetPlayerCharacter();
+
+        if (playerChar == null || playerChar.Address == IntPtr.Zero)
+            return 0;
+
         return ((BattleChara*)playerChar.Address)->Character.ContentId;
     }
 
@@ -780,7 +829,7 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
         bool isDrawingChanged = false;
         if ((nint)drawObj != IntPtr.Zero)
         {
-            isDrawing = (gameObj->RenderFlags & VisibilityFlags.Nameplate) != VisibilityFlags.None;
+            isDrawing = gameObj->RenderFlags == (VisibilityFlags)0b100000000000;
             if (!isDrawing)
             {
                 isDrawing = ((CharacterBase*)drawObj)->HasModelInSlotLoaded != 0;
@@ -846,9 +895,12 @@ public class DalamudUtilService : IHostedService, IMediatorSubscriber
             _performanceCollector.LogPerformance(this, $"TrackedActorsToState",
                 () =>
                 {
-                    _actorObjectService.RefreshTrackedActors();
+                    if (!_actorObjectService.HooksActive || !isNormalFrameworkUpdate || _actorObjectService.HasPendingHashResolutions)
+                    {
+                        _actorObjectService.RefreshTrackedActors();
+                    }
 
-                    var playerDescriptors = _actorObjectService.PlayerCharacterDescriptors;
+                    var playerDescriptors = _actorObjectService.PlayerDescriptors;
                     for (var i = 0; i < playerDescriptors.Count; i++)
                     {
                         var actor = playerDescriptors[i];

LightlessSync/Services/LightFinder/LightFinderPlateHandler.cs

@@ -4,6 +4,7 @@ using Dalamud.Game.Addon.Lifecycle.AddonArgTypes;
 using Dalamud.Game.ClientState.Objects.Enums;
 using Dalamud.Game.Text;
 using Dalamud.Interface;
+using Dalamud.Interface.Utility;
 using Dalamud.Plugin;
 using Dalamud.Plugin.Services;
 using FFXIVClientStructs.FFXIV.Client.System.Framework;
@@ -16,22 +17,27 @@ using LightlessSync.UI;
 using LightlessSync.UI.Services;
 using LightlessSync.Utils;
 using LightlessSync.UtilsEnum.Enum;
-using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 using Pictomancy;
 using System.Collections.Immutable;
 using System.Globalization;
 using System.Numerics;
+using System.Runtime.InteropServices;
 using Task = System.Threading.Tasks.Task;
 
 namespace LightlessSync.Services.LightFinder;
 
+/// <summary>
+/// The new lightfinder nameplate handler using ImGUI (pictomancy) for rendering the icon/labels.
+/// </summary>
 public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscriber
 {
     private readonly ILogger<LightFinderPlateHandler> _logger;
     private readonly IAddonLifecycle _addonLifecycle;
     private readonly IGameGui _gameGui;
     private readonly IObjectTable _objectTable;
+    private readonly IClientState _clientState;
     private readonly LightlessConfigService _configService;
     private readonly PairUiService _pairUiService;
     private readonly LightlessMediator _mediator;
@@ -42,21 +48,33 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
     private bool _needsLabelRefresh;
     private bool _drawSubscribed;
     private AddonNamePlate* _mpNameplateAddon;
-    private readonly object _labelLock = new();
+    private readonly Lock _labelLock = new();
     private readonly NameplateBuffers _buffers = new();
     private int _labelRenderCount;
 
-    private const string DefaultLabelText = "LightFinder";
+    private const string _defaultLabelText = "LightFinder";
-    private const SeIconChar DefaultIcon = SeIconChar.Hyadelyn;
+    private const SeIconChar _defaultIcon = SeIconChar.Hyadelyn;
-    private static readonly string DefaultIconGlyph = SeIconCharExtensions.ToIconString(DefaultIcon);
+    private static readonly string _defaultIconGlyph = SeIconCharExtensions.ToIconString(_defaultIcon);
-    private static readonly Vector2 DefaultPivot = new(0.5f, 1f);
+    private static readonly Vector2 _defaultPivot = new(0.5f, 1f);
+    private uint _lastNamePlateDrawFrame;
 
+    // / Overlay window flags
+    private const ImGuiWindowFlags _overlayFlags =
+    ImGuiWindowFlags.NoDecoration |
+    ImGuiWindowFlags.NoBackground |
+    ImGuiWindowFlags.NoMove |
+    ImGuiWindowFlags.NoSavedSettings |
+    ImGuiWindowFlags.NoNav |
+    ImGuiWindowFlags.NoInputs;
+
+    private readonly List<RectF> _uiRects = new(128);
     private ImmutableHashSet<string> _activeBroadcastingCids = [];
 
     public LightFinderPlateHandler(
         ILogger<LightFinderPlateHandler> logger,
         IAddonLifecycle addonLifecycle,
         IGameGui gameGui,
+        IClientState clientState,
         LightlessConfigService configService,
         LightlessMediator mediator,
         IObjectTable objectTable,
@@ -67,6 +85,7 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         _logger = logger;
         _addonLifecycle = addonLifecycle;
         _gameGui = gameGui;
+        _clientState = clientState;
         _configService = configService;
         _mediator = mediator;
         _objectTable = objectTable;
@@ -101,6 +120,9 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         _mpNameplateAddon = null;
     }
 
+    /// <summary>
+    /// Enable nameplate handling.
+    /// </summary>
     internal void EnableNameplate()
     {
         if (!_mEnabled)
@@ -118,6 +140,9 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         }
     }
 
+    /// <summary>
+    /// Disable nameplate handling.
+    /// </summary>
     internal void DisableNameplate()
     {
         if (_mEnabled)
@@ -136,8 +161,21 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         }
     }
 
+    /// <summary>
+    /// Draw detour for nameplate addon.
+    /// </summary>
+    /// <param name="type"></param>
+    /// <param name="args"></param>
     private void NameplateDrawDetour(AddonEvent type, AddonArgs args)
     {
+        if (_clientState.IsGPosing)
+        {
+            ClearLabelBuffer();
+            Array.Clear(_buffers.HasSmoothed, 0, _buffers.HasSmoothed.Length);
+            _lastNamePlateDrawFrame = 0;
+            return;
+        }
+
         if (args.Addon.Address == nint.Zero)
         {
             if (_logger.IsEnabled(LogLevel.Warning))
@@ -145,6 +183,10 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
             return;
         }
 
+        var fw = Framework.Instance();
+        if (fw != null)
+            _lastNamePlateDrawFrame = fw->FrameCounter;
+
         var pNameplateAddon = (AddonNamePlate*)args.Addon.Address;
 
         if (_mpNameplateAddon != pNameplateAddon)
@@ -156,6 +198,9 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         UpdateNameplateNodes();
     }
 
+    /// <summary>
+    /// Updates the nameplate nodes with LightFinder objects.
+    /// </summary>
     private void UpdateNameplateNodes()
     {
         var currentHandle = _gameGui.GetAddonByName("NamePlate");
@@ -175,6 +220,12 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
             return;
         }
 
+        if (!IsNamePlateAddonVisible())
+        {
+            ClearLabelBuffer();
+            return;
+        }
+
         var framework = Framework.Instance();
         if (framework == null)
         {
@@ -207,7 +258,7 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         }
 
         var visibleUserIdsSnapshot = VisibleUserIds;
-        var safeCount = System.Math.Min(ui3DModule->NamePlateObjectInfoCount, vec.Length);
+        var safeCount = Math.Min(ui3DModule->NamePlateObjectInfoCount, vec.Length);
         var currentConfig = _configService.Current;
         var labelColor = UIColors.Get("Lightfinder");
         var edgeColor = UIColors.Get("LightfinderEdge");
@@ -215,6 +266,7 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
 
         for (int i = 0; i < safeCount; ++i)
         {
+
             var objectInfoPtr = vec[i];
             if (objectInfoPtr == null)
                 continue;
@@ -250,7 +302,6 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
             var root = nameplateObject.RootComponentNode;
             var nameContainer = nameplateObject.NameContainer;
             var nameText = nameplateObject.NameText;
-            var marker = nameplateObject.MarkerIcon;
 
             if (root == null || root->Component == null || nameContainer == null || nameText == null)
             {
@@ -261,14 +312,14 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
 
             root->Component->UldManager.UpdateDrawNodeList();
 
-            bool isVisible =
+            bool isNameplateVisible =
-                (marker != null && marker->AtkResNode.IsVisible()) ||
+                nameContainer->IsVisible() &&
-                (nameContainer->IsVisible() && nameText->AtkResNode.IsVisible()) ||
+                nameText->AtkResNode.IsVisible();
-                currentConfig.LightfinderLabelShowHidden;
 
-            if (!isVisible)
+            if (!currentConfig.LightfinderLabelShowHidden && !isNameplateVisible)
                 continue;
 
+            // Prepare label content and scaling
             var scaleMultiplier = System.Math.Clamp(currentConfig.LightfinderLabelScale, 0.5f, 2.0f);
             var baseScale = currentConfig.LightfinderLabelUseIcon ? 1.0f : 0.5f;
             var effectiveScale = baseScale * scaleMultiplier;
@@ -276,10 +327,10 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
             var targetFontSize = (int)System.Math.Round(baseFontSize * scaleMultiplier);
             var labelContent = currentConfig.LightfinderLabelUseIcon
                 ? NormalizeIconGlyph(currentConfig.LightfinderLabelIconGlyph)
-                : DefaultLabelText;
+                : _defaultLabelText;
 
             if (!currentConfig.LightfinderLabelUseIcon && (string.IsNullOrWhiteSpace(labelContent) || string.Equals(labelContent, "-", StringComparison.Ordinal)))
-                labelContent = DefaultLabelText;
+                labelContent = _defaultLabelText;
 
             var nodeWidth = (int)System.Math.Round(AtkNodeHelpers.DefaultTextNodeWidth * effectiveScale);
             var nodeHeight = (int)System.Math.Round(AtkNodeHelpers.DefaultTextNodeHeight * effectiveScale);
@@ -322,6 +373,7 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
                 () => GetScaledTextWidth(nameText),
                 nodeWidth);
 
+            // Text offset caching
             var textOffset = (int)System.Math.Round(nameText->AtkResNode.X);
             var hasValidOffset = TryCacheTextOffset(nameplateIndex, rawTextWidth, textOffset);
 
@@ -332,65 +384,93 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
                 continue;
             }
 
+            var res = nameContainer;
+
+            // X scale
+            var worldScaleX = GetWorldScaleX(res);
+            if (worldScaleX <= 0f) worldScaleX = 1f;
+
+            // Y scale
+            var worldScaleY = GetWorldScaleY(res);
+            if (worldScaleY <= 0f) worldScaleY = 1f;
+
+            positionY += currentConfig.LightfinderLabelOffsetY;
+            var positionYScreen = positionY * worldScaleY;
+
             float finalX;
             if (currentConfig.LightfinderAutoAlign)
             {
-                var measuredWidth = System.Math.Max(1, textWidth > 0 ? textWidth : nodeWidth);
+                // auto X positioning
+                var measuredWidth = Math.Max(1, textWidth > 0 ? textWidth : nodeWidth);
                 var measuredWidthF = (float)measuredWidth;
-                var alignmentType = currentConfig.LabelAlignment;
 
-                var containerScale = nameContainer->ScaleX;
+                // consider icon width
-                if (containerScale <= 0f)
+                var containerWidthLocal = res->Width > 0 ? res->Width : measuredWidthF;
-                    containerScale = 1f;
+                var containerWidthScreen = containerWidthLocal * worldScaleX;
-                var containerWidthRaw = (float)nameContainer->Width;
-                if (containerWidthRaw <= 0f)
-                    containerWidthRaw = measuredWidthF;
-                var containerWidth = containerWidthRaw * containerScale;
-                if (containerWidth <= 0f)
-                    containerWidth = measuredWidthF;
 
-                var containerLeft = nameContainer->ScreenX;
+                // container bounds for positions
-                var containerRight = containerLeft + containerWidth;
+                var containerLeft = res->ScreenX;
-                var containerCenter = containerLeft + (containerWidth * 0.5f);
+                var containerRight = containerLeft + containerWidthScreen;
+                var containerCenter = containerLeft + (containerWidthScreen * 0.5f);
 
                 var iconMargin = currentConfig.LightfinderLabelUseIcon
-                    ? System.Math.Min(containerWidth * 0.1f, 14f * containerScale)
+                    ? MathF.Min(containerWidthScreen * 0.1f, 14f * worldScaleX)
                     : 0f;
 
-                switch (alignmentType)
+                var offsetXScreen = currentConfig.LightfinderLabelOffsetX * worldScaleX;
+
+                // alignment based on config
+                switch (currentConfig.LabelAlignment)
                 {
                     case LabelAlignment.Left:
-                        finalX = containerLeft + iconMargin;
+                        finalX = containerLeft + iconMargin + offsetXScreen;
                         alignment = AlignmentType.BottomLeft;
                         break;
                     case LabelAlignment.Right:
-                        finalX = containerRight - iconMargin;
+                        finalX = containerRight - iconMargin + offsetXScreen;
                         alignment = AlignmentType.BottomRight;
                         break;
                     default:
-                        finalX = containerCenter;
+                        finalX = containerCenter + offsetXScreen;
                         alignment = AlignmentType.Bottom;
                         break;
                 }
-
-                finalX += currentConfig.LightfinderLabelOffsetX;
             }
             else
             {
+                // manual X positioning
                 var cachedTextOffset = _buffers.TextOffsets[nameplateIndex];
                 var hasCachedOffset = cachedTextOffset != int.MinValue;
-                var baseOffsetX = (!currentConfig.LightfinderLabelUseIcon && hasValidOffset && hasCachedOffset) ? cachedTextOffset : 0;
+                var baseOffsetXLocal = (!currentConfig.LightfinderLabelUseIcon && hasValidOffset && hasCachedOffset)
-                finalX = nameContainer->ScreenX + baseOffsetX + 58 + currentConfig.LightfinderLabelOffsetX;
+                    ? cachedTextOffset
+                    : 0;
+
+                finalX =
+                    res->ScreenX
+                    + (baseOffsetXLocal * worldScaleX)
+                    + (58f * worldScaleX)
+                    + (currentConfig.LightfinderLabelOffsetX * worldScaleX);
+
                 alignment = AlignmentType.Bottom;
             }
 
-            positionY += currentConfig.LightfinderLabelOffsetY;
+            alignment = (AlignmentType)Math.Clamp((int)alignment, 0, 8);
-            alignment = (AlignmentType)System.Math.Clamp((int)alignment, 0, 8);
 
-            var finalPosition = new Vector2(finalX, nameContainer->ScreenY + positionY);
+            // final position before smoothing
+            var finalPosition = new Vector2(finalX, res->ScreenY + positionYScreen);
+            var dpiScale = ImGui.GetIO().DisplayFramebufferScale.X; // often same for Y
+            var fw = Framework.Instance();
+            float dt = fw->RealFrameDeltaTime;
+
+            //smoothing..
+            finalPosition = SnapToPixels(finalPosition, dpiScale);
+            finalPosition = SmoothPosition(nameplateIndex, finalPosition, dt);
+            finalPosition = SnapToPixels(finalPosition, dpiScale);
+
+            // prepare label info
             var pivot = (currentConfig.LightfinderAutoAlign || currentConfig.LightfinderLabelUseIcon)
                 ? AlignmentToPivot(alignment)
-                : DefaultPivot;
+                : _defaultPivot;
             var textColorPacked = PackColor(labelColor);
             var edgeColorPacked = PackColor(edgeColor);
 
@@ -418,11 +498,42 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         }
     }
 
+    /// <summary>
+    /// On each tick, process any needed updates for the UI Builder.
+    /// </summary>
     private void OnUiBuilderDraw()
     {
         if (!_mEnabled)
             return;
 
+        var fw = Framework.Instance();
+        if (fw == null)
+            return;
+
+        // Frame skip check
+        var frame = fw->FrameCounter;
+
+        if (_lastNamePlateDrawFrame == 0 || (frame - _lastNamePlateDrawFrame) > 1)
+        {
+            ClearLabelBuffer();
+            Array.Clear(_buffers.HasSmoothed, 0, _buffers.HasSmoothed.Length);
+
+            return;
+        }
+
+        //Gpose Check
+        if (_clientState.IsGPosing)
+        {
+            ClearLabelBuffer();
+            Array.Clear(_buffers.HasSmoothed, 0, _buffers.HasSmoothed.Length);
+            _lastNamePlateDrawFrame = 0;
+            return;
+        }
+
+        // If nameplate addon is not visible, skip rendering
+        if (!IsNamePlateAddonVisible())
+            return;
+
         int copyCount;
         lock (_labelLock)
         {
@@ -433,21 +544,84 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
             Array.Copy(_buffers.LabelRender, _buffers.LabelCopy, copyCount);
         }
 
+        var uiModule = fw != null ? fw->GetUIModule() : null;
+
+        if (uiModule != null)
+        {
+            var rapture = uiModule->GetRaptureAtkModule();
+            if (rapture != null)
+                RefreshUiRects(&rapture->RaptureAtkUnitManager);
+            else
+                _uiRects.Clear();
+        }
+        else
+        {
+            _uiRects.Clear();
+        }
+
+        // Needed for imgui overlay viewport for the multi window view.
+        var vp = ImGui.GetMainViewport();
+        var vpPos = vp.Pos;
+
+        ImGuiHelpers.ForceNextWindowMainViewport();
+
+        ImGui.SetNextWindowPos(vp.Pos);
+        ImGui.SetNextWindowSize(vp.Size);
+
+        ImGui.PushStyleVar(ImGuiStyleVar.WindowRounding, 0);
+        ImGui.PushStyleVar(ImGuiStyleVar.WindowBorderSize, 0);
+
+        ImGui.Begin("##LightFinderOverlay", _overlayFlags);
+
+        ImGui.PopStyleVar(2);
+
         using var drawList = PictoService.Draw();
         if (drawList == null)
+        {
+            ImGui.End();
             return;
+        }
 
         for (int i = 0; i < copyCount; ++i)
         {
             ref var info = ref _buffers.LabelCopy[i];
+
+            // final draw position with viewport offset
+            var drawPos = info.ScreenPosition + vpPos;
             var font = default(ImFontPtr);
             if (info.UseIcon)
             {
                 var ioFonts = ImGui.GetIO().Fonts;
                 font = ioFonts.Fonts.Size > 1 ? new ImFontPtr(ioFonts.Fonts[1]) : ImGui.GetFont();
             }
+            else
+            {
+                font = ImGui.GetFont();
+            }
 
-            drawList.AddScreenText(info.ScreenPosition, info.Text, info.TextColor, info.FontSize, info.Pivot, info.EdgeColor, font);
+            if (!font.IsNull)
+                ImGui.PushFont(font);
+
+            // calculate size for occlusion checking
+            var baseSize = ImGui.CalcTextSize(info.Text); 
+            var baseFontSize = ImGui.GetFontSize();
+
+            if (!font.IsNull)
+                ImGui.PopFont();
+
+            // scale size based on font size
+            var scale = baseFontSize > 0 ? (info.FontSize / baseFontSize) : 1f;
+            var size = baseSize * scale;
+
+            // label rect for occlusion checking
+            var topLeft = info.ScreenPosition - new Vector2(size.X * info.Pivot.X, size.Y * info.Pivot.Y);
+            var labelRect = new RectF(topLeft.X, topLeft.Y, topLeft.X + size.X, topLeft.Y + size.Y);
+
+            // occlusion check
+            if (IsOccludedByAnyUi(labelRect))
+                continue;
+            
+            drawList.AddScreenText(drawPos, info.Text, info.TextColor, info.FontSize, info.Pivot, info.EdgeColor, font);
         }
     }
 
@@ -460,15 +634,15 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         AlignmentType.Top => new Vector2(0.5f, 0f),
         AlignmentType.Left => new Vector2(0f, 0.5f),
         AlignmentType.Right => new Vector2(1f, 0.5f),
-        _ => DefaultPivot
+        _ => _defaultPivot
     };
 
     private static uint PackColor(Vector4 color)
     {
-        var r = (byte)System.Math.Clamp(color.X * 255f, 0f, 255f);
+        var r = (byte)Math.Clamp(color.X * 255f, 0f, 255f);
-        var g = (byte)System.Math.Clamp(color.Y * 255f, 0f, 255f);
+        var g = (byte)Math.Clamp(color.Y * 255f, 0f, 255f);
-        var b = (byte)System.Math.Clamp(color.Z * 255f, 0f, 255f);
+        var b = (byte)Math.Clamp(color.Z * 255f, 0f, 255f);
-        var a = (byte)System.Math.Clamp(color.W * 255f, 0f, 255f);
+        var a = (byte)Math.Clamp(color.W * 255f, 0f, 255f);
         return (uint)((a << 24) | (b << 16) | (g << 8) | r);
     }
 
@@ -514,10 +688,19 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         if (scale <= 0f)
             scale = 1f;
 
-        var computed = (int)System.Math.Round(rawWidth * scale);
+        var computed = (int)Math.Round(rawWidth * scale);
-        return System.Math.Max(1, computed);
+        return Math.Max(1, computed);
     }
 
+    /// <summary>
+    /// Resolves a cached value for the given index.
+    /// </summary>
+    /// <param name="cache"></param>
+    /// <param name="index"></param>
+    /// <param name="rawValue"></param>
+    /// <param name="fallback"></param>
+    /// <param name="fallbackWhenZero"></param>
+    /// <returns></returns>
     private static int ResolveCache(
         int[] cache,
         int index,
@@ -545,7 +728,7 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
 
     private bool TryCacheTextOffset(int nameplateIndex, int measuredTextWidth, int textOffset)
     {
-        if (System.Math.Abs(measuredTextWidth) > 0 || textOffset != 0)
+        if (Math.Abs(measuredTextWidth) > 0 || textOffset != 0)
         {
             _buffers.TextOffsets[nameplateIndex] = textOffset;
             return true;
@@ -554,10 +737,193 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         return false;
     }
 
+    /// <summary>
+    /// Snapping a position to pixel grid based on DPI scale.
+    /// </summary>
+    /// <param name="p">Position</param>
+    /// <param name="dpiScale">DPI Scale</param>
+    /// <returns></returns>
+    private static Vector2 SnapToPixels(Vector2 p, float dpiScale)
+    {
+        // snap to pixel grid
+        var x = MathF.Round(p.X * dpiScale) / dpiScale;
+        var y = MathF.Round(p.Y * dpiScale) / dpiScale;
+        return new Vector2(x, y);
+    }
+
+
+    /// <summary>
+    /// Smooths the position using exponential smoothing.
+    /// </summary>
+    /// <param name="idx">Nameplate Index</param>
+    /// <param name="target">Final position</param>
+    /// <param name="dt">Delta Time</param>
+    /// <param name="responsiveness">How responssive the smooting should be</param>
+    /// <returns></returns>
+    private Vector2 SmoothPosition(int idx, Vector2 target, float dt, float responsiveness = 24f)
+    {
+        // exponential smoothing
+        if (!_buffers.HasSmoothed[idx])
+        {
+            _buffers.HasSmoothed[idx] = true;
+            _buffers.SmoothedPos[idx] = target;
+            return target;
+        }
+
+        // get current smoothed position
+        var cur = _buffers.SmoothedPos[idx];
+
+        // compute smoothing factor
+        var a = 1f - MathF.Exp(-responsiveness * dt);
+
+        // snap if close enough
+        if (Vector2.DistanceSquared(cur, target) < 0.25f) 
+            return cur;
+
+        // lerp towards target
+        cur = Vector2.Lerp(cur, target, a);
+        _buffers.SmoothedPos[idx] = cur;
+        return cur;
+    }
+
+    /// <summary>
+    /// Tries to get a valid screen rect for the given addon.
+    /// </summary>
+    /// <param name="addon">Addon UI</param>
+    /// <param name="screen">Screen positioning/param>
+    /// <param name="rect">RectF of Addon</param>
+    /// <returns></returns>
+    private static bool TryGetAddonRect(AtkUnitBase* addon, Vector2 screen, out RectF rect)
+    {
+        // Addon existence
+        rect = default;
+        if (addon == null)
+            return false;
+
+        // Visibility check
+        var root = addon->RootNode;
+        if (root == null || !root->IsVisible())
+            return false;
+
+        // Size check
+        float w = root->Width;
+        float h = root->Height;
+        if (w <= 0 || h <= 0)
+            return false;
+
+        // Local scale
+        float sx = root->ScaleX; if (sx <= 0f) sx = 1f;
+        float sy = root->ScaleY; if (sy <= 0f) sy = 1f;
+
+        // World/composed scale from Transform
+        float wsx = GetWorldScaleX(root);
+        float wsy = GetWorldScaleY(root);
+        if (wsx <= 0f) wsx = 1f;
+        if (wsy <= 0f) wsy = 1f;
+
+        // World scale may include parent scaling; use it if meaningfully different.
+        float useX = MathF.Abs(wsx - sx) > 0.01f ? wsx : sx;
+        float useY = MathF.Abs(wsy - sy) > 0.01f ? wsy : sy;
+
+        w *= useX;
+        h *= useY;
+
+        if (w < 4f || h < 4f)
+            return false;
+
+        // Screen coords
+        float l = root->ScreenX;
+        float t = root->ScreenY;
+        float r = l + w;
+        float b = t + h;
+
+        // Drop fullscreen-ish / insane rects
+        if (w >= screen.X * 0.98f && h >= screen.Y * 0.98f)
+            return false;
+
+        // Drop offscreen rects
+        if (l < -screen.X || t < -screen.Y || r > screen.X * 2f || b > screen.Y * 2f)
+            return false;
+
+        rect = new RectF(l, t, r, b);
+        return true;
+    }
+
+    /// <summary>
+    /// Refreshes the cached UI rects for occlusion checking.
+    /// </summary>
+    /// <param name="unitMgr">Unit Manager</param>
+    private void RefreshUiRects(RaptureAtkUnitManager* unitMgr)
+    {
+        _uiRects.Clear();
+        if (unitMgr == null)
+            return;
+
+        var screen = ImGui.GetIO().DisplaySize;
+
+        ref var list = ref unitMgr->AllLoadedUnitsList;
+        var count = (int)list.Count;
+
+        for (int i = 0; i < count; i++)
+        {
+            var addon = list.Entries[i].Value;
+            if (addon == null)
+                continue;
+
+            if (_mpNameplateAddon != null && addon == (AtkUnitBase*)_mpNameplateAddon)
+                continue;
+
+            if (TryGetAddonRect(addon, screen, out var r))
+                _uiRects.Add(r);
+        }
+    }
+
+    /// <summary>
+    /// Is the given label rect occluded by any UI rects?
+    /// </summary>
+    /// <param name="labelRect">UI/Label Rect</param>
+    /// <returns>Is occluded or not</returns>
+    private bool IsOccludedByAnyUi(RectF labelRect)
+    {
+        for (int i = 0; i < _uiRects.Count; i++)
+        {
+            if (_uiRects[i].Intersects(labelRect))
+                return true;
+        }
+        return false;
+    }
+
+    /// <summary>
+    /// Gets the world scale X of the given node.
+    /// </summary>
+    /// <param name="n">Node</param>
+    /// <returns>World Scale of node</returns>
+    private static float GetWorldScaleX(AtkResNode* n)
+    {
+        var t = n->Transform;
+        return MathF.Sqrt(t.M11 * t.M11 + t.M12 * t.M12);
+    }
+
+    /// <summary>
+    /// Gets the world scale Y of the given node.
+    /// </summary>
+    /// <param name="n">Node</param>
+    /// <returns>World Scale of node</returns>
+    private static float GetWorldScaleY(AtkResNode* n)
+    {
+        var t = n->Transform;
+        return MathF.Sqrt(t.M21 * t.M21 + t.M22 * t.M22);
+    }
+
+    /// <summary>
+    /// Normalize an icon glyph input into a valid string.
+    /// </summary>
+    /// <param name="rawInput">Raw glyph input</param>
+    /// <returns>Normalized glyph input</returns>
     internal static string NormalizeIconGlyph(string? rawInput)
     {
         if (string.IsNullOrWhiteSpace(rawInput))
-            return DefaultIconGlyph;
+            return _defaultIconGlyph;
 
         var trimmed = rawInput.Trim();
 
@@ -575,17 +941,36 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         if (enumerator.MoveNext())
             return enumerator.Current.ToString();
 
-        return DefaultIconGlyph;
+        return _defaultIconGlyph;
     }
 
+    /// <summary>
+    /// Is the nameplate addon visible?
+    /// </summary>
+    /// <returns>Is it visible?</returns>
+    private bool IsNamePlateAddonVisible()
+    {
+        if (_mpNameplateAddon == null)
+            return false;
+
+        var root = _mpNameplateAddon->AtkUnitBase.RootNode;
+        return root != null && root->IsVisible();
+    }
+
+    /// <summary>
+    /// Converts raw icon glyph input into an icon editor string.
+    /// </summary>
+    /// <param name="rawInput">Raw icon glyph input</param>
+    /// <returns>Icon editor string</returns>
     internal static string ToIconEditorString(string? rawInput)
     {
         var normalized = NormalizeIconGlyph(rawInput);
         var runeEnumerator = normalized.EnumerateRunes();
         return runeEnumerator.MoveNext()
             ? runeEnumerator.Current.Value.ToString("X4", CultureInfo.InvariantCulture)
-            : DefaultIconGlyph;
+            : _defaultIconGlyph;
     }
+
     private readonly struct NameplateLabelInfo
     {
         public NameplateLabelInfo(
@@ -615,6 +1000,9 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         public bool UseIcon { get; }
     }
 
+    /// <summary>
+    /// Visible paired user IDs snapshot.
+    /// </summary>
     private HashSet<ulong> VisibleUserIds
         => [.. _pairUiService.GetSnapshot().PairsByUid.Values
             .Where(u => u.IsVisible && u.PlayerCharacterId != uint.MaxValue)
@@ -634,6 +1022,10 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         }
     }
 
+    /// <summary>
+    /// Update the active broadcasting CIDs.
+    /// </summary>
+    /// <param name="cids">Inbound new CIDs</param>
     public void UpdateBroadcastingCids(IEnumerable<string> cids)
     {
         var newSet = cids.ToImmutableHashSet(StringComparer.Ordinal);
@@ -646,10 +1038,16 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         FlagRefresh();
     }
 
+    /// <summary>
+    /// Clears all nameplate related caches.
+    /// </summary>
     public void ClearNameplateCaches()
     {
         _buffers.Clear();
         ClearLabelBuffer();
+
+        Array.Clear(_buffers.HasSmoothed, 0, _buffers.HasSmoothed.Length);
+        Array.Clear(_buffers.SmoothedPos, 0, _buffers.SmoothedPos.Length);
     }
 
     private sealed class NameplateBuffers
@@ -668,6 +1066,10 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         public NameplateLabelInfo[] LabelRender { get; } = new NameplateLabelInfo[AddonNamePlate.NumNamePlateObjects];
         public NameplateLabelInfo[] LabelCopy { get; } = new NameplateLabelInfo[AddonNamePlate.NumNamePlateObjects];
 
+        public Vector2[] SmoothedPos = new Vector2[AddonNamePlate.NumNamePlateObjects];
+
+        public bool[] HasSmoothed = new bool[AddonNamePlate.NumNamePlateObjects];
+
         public void Clear()
         {
             System.Array.Clear(TextWidths, 0, TextWidths.Length);
@@ -677,16 +1079,38 @@ public unsafe class LightFinderPlateHandler : IHostedService, IMediatorSubscribe
         }
     }
 
+    /// <summary>
+    /// Starts the LightFinder Plate Handler.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation Token</param>
+    /// <returns>Task Completed</returns>
     public Task StartAsync(CancellationToken cancellationToken)
     {
         Init();
         return Task.CompletedTask;
     }
 
+    /// <summary>
+    /// Stops the LightFinder Plate Handler.
+    /// </summary>
+    /// <param name="cancellationToken">Cancellation Token</param>
+    /// <returns>Task Completed</returns>
     public Task StopAsync(CancellationToken cancellationToken)
     {
         Uninit();
         return Task.CompletedTask;
     }
 
+    /// <summary>
+    /// Rectangle with float coordinates for intersection testing.
+    /// </summary>
+    [StructLayout(LayoutKind.Auto)]
+    private readonly struct RectF
+    {
+        public readonly float L, T, R, B;
+        public RectF(float l, float t, float r, float b) { L = l; T = t; R = r; B = b; }
+
+        public bool Intersects(in RectF o) =>
+            !(R <= o.L || o.R <= L || B <= o.T || o.B <= T);
+    }
 }

LightlessSync/Services/LightFinder/LightFinderScannerService.cs

@@ -148,10 +148,14 @@ public class LightFinderScannerService : DisposableMediatorSubscriberBase
     private void UpdateSyncshellBroadcasts()
     {
         var now = DateTime.UtcNow;
-        var newSet = _broadcastCache
+        var nearbyCids = GetNearbyHashedCids(out _);
-            .Where(e => e.Value.IsBroadcasting && e.Value.ExpiryTime > now && !string.IsNullOrEmpty(e.Value.GID))
+        var newSet = nearbyCids.Count == 0
-            .Select(e => e.Key)
+            ? new HashSet<string>(StringComparer.Ordinal)
-            .ToHashSet(StringComparer.Ordinal);
+            : _broadcastCache
+                .Where(e => e.Value.IsBroadcasting && e.Value.ExpiryTime > now && !string.IsNullOrEmpty(e.Value.GID))
+                .Where(e => nearbyCids.Contains(e.Key))
+                .Select(e => e.Key)
+                .ToHashSet(StringComparer.Ordinal);
 
         if (!_syncshellCids.SetEquals(newSet))
         {
@@ -163,12 +167,17 @@ public class LightFinderScannerService : DisposableMediatorSubscriberBase
         }
     }
 
-    public List<BroadcastStatusInfoDto> GetActiveSyncshellBroadcasts()
+    public List<BroadcastStatusInfoDto> GetActiveSyncshellBroadcasts(bool excludeLocal = false)
     {
         var now = DateTime.UtcNow;
+        var nearbyCids = GetNearbyHashedCids(out var localCid);
+        if (nearbyCids.Count == 0)
+            return [];
 
         return [.. _broadcastCache
             .Where(e => e.Value.IsBroadcasting && e.Value.ExpiryTime > now && !string.IsNullOrEmpty(e.Value.GID))
+            .Where(e => nearbyCids.Contains(e.Key))
+            .Where(e => !excludeLocal || !string.Equals(e.Key, localCid, StringComparison.Ordinal))
             .Select(e => new BroadcastStatusInfoDto
             {
                 HashedCID = e.Key,
@@ -178,6 +187,47 @@ public class LightFinderScannerService : DisposableMediatorSubscriberBase
             })];
     }
 
+    public bool TryGetLocalHashedCid(out string hashedCid)
+    {
+        hashedCid = string.Empty;
+        var descriptors = _actorTracker.PlayerDescriptors;
+        if (descriptors.Count == 0)
+            return false;
+
+        foreach (var descriptor in descriptors)
+        {
+            if (!descriptor.IsLocalPlayer || string.IsNullOrWhiteSpace(descriptor.HashedContentId))
+                continue;
+
+            hashedCid = descriptor.HashedContentId;
+            return true;
+        }
+
+        return false;
+    }
+
+    private HashSet<string> GetNearbyHashedCids(out string? localCid)
+    {
+        localCid = null;
+        var descriptors = _actorTracker.PlayerDescriptors;
+        if (descriptors.Count == 0)
+            return new HashSet<string>(StringComparer.Ordinal);
+
+        var set = new HashSet<string>(StringComparer.Ordinal);
+        foreach (var descriptor in descriptors)
+        {
+            if (string.IsNullOrWhiteSpace(descriptor.HashedContentId))
+                continue;
+
+            if (descriptor.IsLocalPlayer)
+                localCid = descriptor.HashedContentId;
+
+            set.Add(descriptor.HashedContentId);
+        }
+
+        return set;
+    }
+
     private async Task ExpiredBroadcastCleanupLoop()
     {
         var token = _cleanupCts.Token;

LightlessSync/Services/TextureCompression/TextureMetadataHelper.cs

@@ -126,11 +126,11 @@ public sealed class TextureMetadataHelper
     private const string TextureSegment = "/texture/";
     private const string MaterialSegment = "/material/";
 
-    private const uint NormalSamplerId = 0x0C5EC1F1u;
+    private const uint NormalSamplerId = ShpkFile.NormalSamplerId;
-    private const uint IndexSamplerId = 0x565F8FD8u;
+    private const uint IndexSamplerId = ShpkFile.IndexSamplerId;
-    private const uint SpecularSamplerId = 0x2B99E025u;
+    private const uint SpecularSamplerId = ShpkFile.SpecularSamplerId;
-    private const uint DiffuseSamplerId = 0x115306BEu;
+    private const uint DiffuseSamplerId = ShpkFile.DiffuseSamplerId;
-    private const uint MaskSamplerId = 0x8A4E82B6u;
+    private const uint MaskSamplerId = ShpkFile.MaskSamplerId;
 
     public TextureMetadataHelper(ILogger<TextureMetadataHelper> logger, IDataManager dataManager)
     {

LightlessSync/UI/CompactUI.cs

@@ -843,12 +843,16 @@ public class CompactUi : WindowMediatorSubscriberBase
 
             //Filter of not grouped/foldered and offline pairs
             var allOnlineNotTaggedPairs = SortEntries(allEntries.Where(FilterNotTaggedUsers));
-            var onlineNotTaggedPairs = SortEntries(filteredEntries.Where(e => FilterNotTaggedUsers(e) && FilterOnlineOrPausedSelf(e)));
+            if (allOnlineNotTaggedPairs.Count > 0 && _configService.Current.ShowOfflineUsersSeparately) {
-
+                var filteredOnlineEntries = SortOnlineEntries(filteredEntries.Where(e => FilterNotTaggedUsers(e) && FilterOnlineOrPausedSelf(e)));
-            if (allOnlineNotTaggedPairs.Count > 0)
-            {
                 drawFolders.Add(_drawEntityFactory.CreateTagFolder(
-                    _configService.Current.ShowOfflineUsersSeparately ? TagHandler.CustomOnlineTag : TagHandler.CustomAllTag,
+                    TagHandler.CustomOnlineTag,
+                    filteredOnlineEntries,
+                    allOnlineNotTaggedPairs));
+            } else if (allOnlineNotTaggedPairs.Count > 0 && !_configService.Current.ShowOfflineUsersSeparately) {
+                var onlineNotTaggedPairs = SortEntries(filteredEntries.Where(FilterNotTaggedUsers));
+                drawFolders.Add(_drawEntityFactory.CreateTagFolder(
+                    TagHandler.CustomAllTag,
                     onlineNotTaggedPairs,
                     allOnlineNotTaggedPairs));
             }
@@ -885,7 +889,7 @@ public class CompactUi : WindowMediatorSubscriberBase
         }
     }
 
-    private bool PassesFilter(PairUiEntry entry, string filter)
+    private static bool PassesFilter(PairUiEntry entry, string filter)
     {
         if (string.IsNullOrEmpty(filter)) return true;
 
@@ -946,6 +950,17 @@ public class CompactUi : WindowMediatorSubscriberBase
         };
     }
 
+    private ImmutableList<PairUiEntry> SortOnlineEntries(IEnumerable<PairUiEntry> entries)
+    {
+        var entryList = entries.ToList();
+        return _configService.Current.OnlinePairSortMode switch
+        {
+            OnlinePairSortMode.Alphabetical => [.. entryList.OrderBy(e => AlphabeticalSortKey(e), StringComparer.OrdinalIgnoreCase)],
+            OnlinePairSortMode.PreferredDirectPairs => SortVisibleByPreferred(entryList),
+            _ => SortEntries(entryList),
+        };
+    }
+
     private ImmutableList<PairUiEntry> SortVisibleByMetric(IEnumerable<PairUiEntry> entries, Func<PairUiEntry, long> selector)
     {
         return [.. entries

LightlessSync/UI/Components/DrawFolderBase.cs

@@ -4,8 +4,8 @@ using Dalamud.Interface.Utility.Raii;
 using LightlessSync.UI.Handlers;
 using LightlessSync.UI.Models;
 using System.Collections.Immutable;
-using LightlessSync.UI;
 using LightlessSync.UI.Style;
+using OtterGui.Text;
 
 namespace LightlessSync.UI.Components;
 
@@ -113,9 +113,13 @@ public abstract class DrawFolderBase : IDrawFolder
             using var indent = ImRaii.PushIndent(_uiSharedService.GetIconSize(FontAwesomeIcon.EllipsisV).X + ImGui.GetStyle().ItemSpacing.X, false);
             if (DrawPairs.Any())
             {
-                foreach (var item in DrawPairs)
+                using var clipper = ImUtf8.ListClipper(DrawPairs.Count, ImGui.GetFrameHeightWithSpacing());
+                while (clipper.Step())
                 {
-                    item.DrawPairedClient();
+                    for (var i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
+                    {
+                        DrawPairs[i].DrawPairedClient();
+                    }
                 }
             }
             else

LightlessSync/UI/Components/DrawFolderTag.cs

@@ -169,11 +169,16 @@ public class DrawFolderTag : DrawFolderBase
 
     protected override float DrawRightSide(float currentRightSideX)
     {
-        if (_id == TagHandler.CustomVisibleTag)
+        if (string.Equals(_id, TagHandler.CustomVisibleTag, StringComparison.Ordinal))
         {
             return DrawVisibleFilter(currentRightSideX);
         }
 
+        if (string.Equals(_id, TagHandler.CustomOnlineTag, StringComparison.Ordinal))
+        {
+            return DrawOnlineFilter(currentRightSideX);
+        }
+
         if (!RenderPause)
         {
             return currentRightSideX;
@@ -254,7 +259,7 @@ public class DrawFolderTag : DrawFolderBase
             foreach (VisiblePairSortMode mode in Enum.GetValues<VisiblePairSortMode>())
             {
                 var selected = _configService.Current.VisiblePairSortMode == mode;
-                if (ImGui.MenuItem(GetSortLabel(mode), string.Empty, selected))
+                if (ImGui.MenuItem(GetSortVisibleLabel(mode), string.Empty, selected))
                 {
                     if (!selected)
                     {
@@ -273,7 +278,49 @@ public class DrawFolderTag : DrawFolderBase
         return buttonStart - spacingX;
     }
 
-    private static string GetSortLabel(VisiblePairSortMode mode) => mode switch
+    private float DrawOnlineFilter(float currentRightSideX)
+    {
+        var buttonSize = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Filter);
+        var spacingX = ImGui.GetStyle().ItemSpacing.X;
+        var buttonStart = currentRightSideX - buttonSize.X;
+
+        ImGui.SameLine(buttonStart);
+        if (_uiSharedService.IconButton(FontAwesomeIcon.Filter))
+        {
+            SuppressNextRowToggle();
+            ImGui.OpenPopup($"online-filter-{_id}");
+        }
+
+        UiSharedService.AttachToolTip("Adjust how online pairs are ordered.");
+
+        if (ImGui.BeginPopup($"online-filter-{_id}"))
+        {
+            ImGui.TextUnformatted("Online Pair Ordering");
+            ImGui.Separator();
+
+            foreach (OnlinePairSortMode mode in Enum.GetValues<OnlinePairSortMode>())
+            {
+                var selected = _configService.Current.OnlinePairSortMode == mode;
+                if (ImGui.MenuItem(GetSortOnlineLabel(mode), string.Empty, selected))
+                {
+                    if (!selected)
+                    {
+                        _configService.Current.OnlinePairSortMode = mode;
+                        _configService.Save();
+                        _mediator.Publish(new RefreshUiMessage());
+                    }
+
+                    ImGui.CloseCurrentPopup();
+                }
+            }
+
+            ImGui.EndPopup();
+        }
+
+        return buttonStart - spacingX;
+    }
+
+    private static string GetSortVisibleLabel(VisiblePairSortMode mode) => mode switch
     {
         VisiblePairSortMode.Alphabetical => "Alphabetical",
         VisiblePairSortMode.VramUsage => "VRAM usage (descending)",
@@ -282,4 +329,11 @@ public class DrawFolderTag : DrawFolderBase
         VisiblePairSortMode.PreferredDirectPairs => "Preferred permissions & Direct pairs",
         _ => "Default",
     };
+
+    private static string GetSortOnlineLabel(OnlinePairSortMode mode) => mode switch
+    {
+        OnlinePairSortMode.Alphabetical => "Alphabetical",
+        OnlinePairSortMode.PreferredDirectPairs => "Preferred permissions & Direct pairs",
+        _ => "Default",
+    };
 }

LightlessSync/UI/Components/DrawUserPair.cs

@@ -133,6 +133,26 @@ public class DrawUserPair
             UiSharedService.AttachToolTip("This reapplies the last received character data to this character");
         }
 
+        var isPaused = _pair.UserPair!.OwnPermissions.IsPaused();
+        if (!isPaused)
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Pause, "Toggle Pause State", _menuWidth, true))
+            {
+                _ = _apiController.PauseAsync(_pair.UserData);
+                ImGui.CloseCurrentPopup();
+            }
+            UiSharedService.AttachToolTip("Pauses syncing with this user.");
+        }
+        else
+        {
+            if (_uiSharedService.IconTextButton(FontAwesomeIcon.Play, "Toggle Unpause State", _menuWidth, true))
+            {
+                _ = _apiController.UnpauseAsync(_pair.UserData);
+                ImGui.CloseCurrentPopup();
+            }
+            UiSharedService.AttachToolTip("Resumes syncing with this user.");
+        }
+
         if (_uiSharedService.IconTextButton(FontAwesomeIcon.PlayCircle, "Cycle pause state", _menuWidth, true))
         {
             _ = _apiController.CyclePauseAsync(_pair);

LightlessSync/UI/DownloadUi.cs

@@ -164,7 +164,18 @@ public class DownloadUi : WindowMediatorSubscriberBase
         const float rounding = 6f;
         var shadowOffset = new Vector2(2, 2);
 
-        foreach (var transfer in _currentDownloads.ToList())
+        List<KeyValuePair<GameObjectHandler, Dictionary<string, FileDownloadStatus>>> transfers;
+        try
+        {
+            transfers = _currentDownloads.ToList();
+        }
+        catch (ArgumentException)
+        {
+            return;
+        }
+
+
+        foreach (var transfer in transfers)
         {
             var transferKey = transfer.Key;
             var rawPos = _dalamudUtilService.WorldToScreen(transferKey.GetGameObject());

LightlessSync/UI/LightFinderUI.cs

@@ -301,6 +301,14 @@ namespace LightlessSync.UI
                     bool ShellFinderEnabled = _configService.Current.SyncshellFinderEnabled;
                     bool isBroadcasting = _broadcastService.IsBroadcasting;
 
+                    if (isBroadcasting)
+                    {
+                        var warningColor = UIColors.Get("LightlessYellow");
+                        _uiSharedService.DrawNoteLine("! ", warningColor,
+                            new SeStringUtils.RichTextEntry("Syncshell Finder can only be changed while Lightfinder is disabled.", warningColor));
+                        ImGuiHelpers.ScaledDummy(0.2f);
+                    }
+
                     if (isBroadcasting)
                         ImGui.BeginDisabled();
 

LightlessSync/UI/Models/OnlinePairSortMode.cs

@@ -0,0 +1,7 @@
+namespace LightlessSync.UI.Models;
+
+public enum OnlinePairSortMode
+{
+    Alphabetical = 0,
+    PreferredDirectPairs = 1,
+}

LightlessSync/UI/Models/VisiblePairSortMode.cs

@@ -2,10 +2,9 @@ namespace LightlessSync.UI.Models;
 
 public enum VisiblePairSortMode
 {
-    Default = 0,
+    Alphabetical = 0,
-    Alphabetical = 1,
+    VramUsage = 1,
-    VramUsage = 2,
+    EffectiveVramUsage = 2,
-    EffectiveVramUsage = 3,
+    TriangleCount = 3,
-    TriangleCount = 4,
+    PreferredDirectPairs = 4,
-    PreferredDirectPairs = 5,
 }

LightlessSync/UI/Style/AnimatedHeader.cs

@@ -222,7 +222,9 @@ public class AnimatedHeader
 
                     if (ImGui.IsItemHovered() && !string.IsNullOrEmpty(button.Tooltip))
                     {
+                        ImGui.PushFont(UiBuilder.DefaultFont);
                         ImGui.SetTooltip(button.Tooltip);
+                        ImGui.PopFont();
                     }
 
                     currentX -= buttonSize.X + spacing;

LightlessSync/UI/SyncshellAdminUI.cs

@@ -297,6 +297,25 @@ public class SyncshellAdminUI : WindowMediatorSubscriberBase
             var ownerTab = ImRaii.TabItem("Owner Settings");
             if (ownerTab)
             {
+                bool isChatDisabled = perm.IsDisableChat();
+                ImGui.AlignTextToFramePadding();
+                ImGui.TextUnformatted("Syncshell Chat");
+                _uiSharedService.BooleanToColoredIcon(!isChatDisabled);
+                ImGui.SameLine(230);
+                using (ImRaii.PushColor(ImGuiCol.Text, isChatDisabled ? UIColors.Get("PairBlue") : UIColors.Get("DimRed")))
+                {
+                    if (_uiSharedService.IconTextButton(
+                        isChatDisabled ? FontAwesomeIcon.Comment : FontAwesomeIcon.Ban,
+                        isChatDisabled ? "Enable syncshell chat" : "Disable syncshell chat"))
+                    {
+                        perm.SetDisableChat(!isChatDisabled);
+                        _ = _apiController.GroupChangeGroupPermissionState(new(GroupFullInfo.Group, perm));
+                    }
+                }
+                UiSharedService.AttachToolTip("Disables syncshell chat for all members.");
+
+                ImGuiHelpers.ScaledDummy(6f);
+
                 ImGui.AlignTextToFramePadding();
                 ImGui.TextUnformatted("New Password");
                 var availableWidth = ImGui.GetWindowContentRegionMax().X - ImGui.GetWindowContentRegionMin().X;

LightlessSync/UI/SyncshellFinderUI.cs

@@ -140,19 +140,10 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
             return;
         }
 
-        string? myHashedCid = null;
+        var broadcasts = _broadcastScannerService.GetActiveSyncshellBroadcasts().ToList() ?? [];
-        try
+        _broadcastScannerService.TryGetLocalHashedCid(out var localHashedCid);
-        {
-            var cid = _dalamudUtilService.GetCID();
-            myHashedCid = cid.ToString().GetHash256();
-        }
-        catch (Exception ex)
-        {
-            _logger.LogDebug(ex, "Failed to get CID, not excluding own broadcast.");
-        }
-        var broadcasts = _broadcastScannerService.GetActiveSyncshellBroadcasts().Where(b => !string.Equals(b.HashedCID, myHashedCid, StringComparison.Ordinal)).ToList() ?? [];
 
-        var cardData = new List<(GroupJoinDto Shell, string BroadcasterName)>();
+        var cardData = new List<(GroupJoinDto Shell, string BroadcasterName, bool IsSelfBroadcast)>();
 
         foreach (var shell in _nearbySyncshells)
         {
@@ -185,9 +176,15 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
                 broadcasterName = !string.IsNullOrEmpty(worldName)
                     ? $"{name} ({worldName})"
                     : name;
+
+                var isSelfBroadcast = !string.IsNullOrEmpty(localHashedCid)
+                    && string.Equals(broadcast.HashedCID, localHashedCid, StringComparison.Ordinal);
+
+                cardData.Add((shell, broadcasterName, isSelfBroadcast));
+                continue;
             }
 
-            cardData.Add((shell, broadcasterName));
+            cardData.Add((shell, broadcasterName, false));
         }
 
         if (cardData.Count == 0)
@@ -210,7 +207,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
             DrawConfirmation();
     }
 
-    private void DrawSyncshellList(List<(GroupJoinDto Shell, string BroadcasterName)> listData)
+    private void DrawSyncshellList(List<(GroupJoinDto Shell, string BroadcasterName, bool IsSelfBroadcast)> listData)
     {
         const int shellsPerPage = 3;
         var totalPages = (int)Math.Ceiling(listData.Count / (float)shellsPerPage);
@@ -227,7 +224,10 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
 
         for (int index = firstIndex; index < lastExclusive; index++)
         {
-            var (shell, broadcasterName) = listData[index];
+            var (shell, broadcasterName, isSelfBroadcast) = listData[index];
+            var broadcasterLabel = string.IsNullOrEmpty(broadcasterName)
+                ? (isSelfBroadcast ? "You" : string.Empty)
+                : (isSelfBroadcast ? $"{broadcasterName} (You)" : broadcasterName);
 
             ImGui.PushID(shell.Group.GID);
             float rowHeight = 74f * ImGuiHelpers.GlobalScale;
@@ -239,7 +239,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
             var style = ImGui.GetStyle();
             float startX = ImGui.GetCursorPosX();
             float regionW = ImGui.GetContentRegionAvail().X;
-            float rightTxtW = ImGui.CalcTextSize(broadcasterName).X;
+            float rightTxtW = ImGui.CalcTextSize(broadcasterLabel).X;
 
             _uiSharedService.MediumText(displayName, UIColors.Get("LightlessPurple"));
             if (ImGui.IsItemHovered())
@@ -252,7 +252,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
             float rightX = startX + regionW - rightTxtW - style.ItemSpacing.X;
             ImGui.SameLine();
             ImGui.SetCursorPosX(rightX);
-            ImGui.TextUnformatted(broadcasterName);
+            ImGui.TextUnformatted(broadcasterLabel);
             if (ImGui.IsItemHovered())
                 ImGui.SetTooltip("Broadcaster of the syncshell.");
 
@@ -291,7 +291,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
             float joinX = rowStartLocal.X + (tagsWidth > 0 ? tagsWidth + style.ItemSpacing.X : 0f);
 
             ImGui.SetCursorPos(new Vector2(joinX, btnBaselineY));
-            DrawJoinButton(shell);
+            DrawJoinButton(shell, isSelfBroadcast);
 
             float btnHeight = ImGui.GetFrameHeightWithSpacing();
             float rowHeightUsed = MathF.Max(tagsHeight, btnHeight);
@@ -311,7 +311,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
         DrawPagination(totalPages);
     }
 
-    private void DrawSyncshellGrid(List<(GroupJoinDto Shell, string BroadcasterName)> cardData)
+    private void DrawSyncshellGrid(List<(GroupJoinDto Shell, string BroadcasterName, bool IsSelfBroadcast)> cardData)
     {
         const int shellsPerPage = 4;
         var totalPages = (int)Math.Ceiling(cardData.Count / (float)shellsPerPage);
@@ -336,7 +336,10 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
         for (int index = firstIndex; index < lastExclusive; index++)
         {
             var localIndex = index - firstIndex;
-            var (shell, broadcasterName) = cardData[index];
+            var (shell, broadcasterName, isSelfBroadcast) = cardData[index];
+            var broadcasterLabel = string.IsNullOrEmpty(broadcasterName)
+                ? (isSelfBroadcast ? "You" : string.Empty)
+                : (isSelfBroadcast ? $"{broadcasterName} (You)" : broadcasterName);
 
             if (localIndex % 2 != 0)
                 ImGui.SameLine();
@@ -350,9 +353,9 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
                 ? shell.Group.Alias
                 : shell.Group.GID;
 
+            var style = ImGui.GetStyle();
             float startX = ImGui.GetCursorPosX();
-            float availWidth = ImGui.GetContentRegionAvail().X;
+            float availW = ImGui.GetContentRegionAvail().X;
-            float rightTextW = ImGui.CalcTextSize(broadcasterName).X;
 
             ImGui.BeginGroup();
 
@@ -364,13 +367,45 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
                 Mediator.Publish(new GroupProfileOpenStandaloneMessage(shell.Group));
             }
 
-            ImGui.SameLine();
+            float nameRightX = ImGui.GetItemRectMax().X;
-            float rightX = startX + availWidth - rightTextW;
+
-            var pos = ImGui.GetCursorPos();
+            var regionMinScreen = ImGui.GetCursorScreenPos();
-            ImGui.SetCursorPos(new Vector2(rightX, pos.Y + 3f * ImGuiHelpers.GlobalScale));
+            float regionRightX = regionMinScreen.X + availW;
-            ImGui.TextUnformatted(broadcasterName);
+
-            if (ImGui.IsItemHovered())
+            float minBroadcasterX = nameRightX + style.ItemSpacing.X;
-                ImGui.SetTooltip("Broadcaster of the syncshell.");
+
+            float maxBroadcasterWidth = regionRightX - minBroadcasterX;
+
+            string broadcasterToShow = broadcasterLabel;
+
+            if (!string.IsNullOrEmpty(broadcasterLabel) && maxBroadcasterWidth > 0f)
+            {
+                float bcFullWidth = ImGui.CalcTextSize(broadcasterLabel).X;
+                string toolTip;
+
+                if (bcFullWidth > maxBroadcasterWidth)
+                {
+                    broadcasterToShow = TruncateTextToWidth(broadcasterLabel, maxBroadcasterWidth);
+                    toolTip = broadcasterLabel + Environment.NewLine + Environment.NewLine + "Broadcaster of the syncshell.";
+                } 
+                else
+                {
+                    toolTip = "Broadcaster of the syncshell.";
+                }
+
+                float bcWidth = ImGui.CalcTextSize(broadcasterToShow).X;
+
+                float broadX = regionRightX - bcWidth;
+
+                broadX = MathF.Max(broadX, minBroadcasterX);
+
+                ImGui.SameLine();
+                var curPos = ImGui.GetCursorPos();
+                ImGui.SetCursorPos(new Vector2(broadX - regionMinScreen.X + startX, curPos.Y + 3f * ImGuiHelpers.GlobalScale));
+                ImGui.TextUnformatted(broadcasterToShow);
+                if (ImGui.IsItemHovered())
+                    ImGui.SetTooltip(toolTip);
+            }
 
             ImGui.EndGroup();
 
@@ -411,7 +446,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
             if (remainingY > 0)
                 ImGui.Dummy(new Vector2(0, remainingY));
 
-            DrawJoinButton(shell);
+            DrawJoinButton(shell, isSelfBroadcast);
 
             ImGui.EndChild();
             ImGui.EndGroup();
@@ -457,7 +492,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
         }
     }
 
-    private void DrawJoinButton(dynamic shell)
+    private void DrawJoinButton(GroupJoinDto shell, bool isSelfBroadcast)
     {
         const string visibleLabel = "Join";
         var label = $"{visibleLabel}##{shell.Group.GID}";
@@ -485,7 +520,7 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
             buttonSize = new Vector2(-1, 0);
         }
 
-        if (!isAlreadyMember && !isRecentlyJoined)
+        if (!isAlreadyMember && !isRecentlyJoined && !isSelfBroadcast)
         {
             ImGui.PushStyleColor(ImGuiCol.Button, UIColors.Get("LightlessGreen"));
             ImGui.PushStyleColor(ImGuiCol.ButtonHovered, UIColors.Get("LightlessGreen").WithAlpha(0.85f));
@@ -535,7 +570,9 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
                 ImGui.Button(label, buttonSize);
             }
 
-            UiSharedService.AttachToolTip("Already a member or owner of this Syncshell.");
+            UiSharedService.AttachToolTip(isSelfBroadcast
+                ? "This is your own Syncshell."
+                : "Already a member or owner of this Syncshell.");
         }
 
         ImGui.PopStyleColor(3);
@@ -590,6 +627,40 @@ public class SyncshellFinderUI : WindowMediatorSubscriberBase
         float widthUsed = cursorLocalX - baseLocal.X;
         return (widthUsed, rowHeight);
     }
+    private static string TruncateTextToWidth(string text, float maxWidth)
+    {
+        if (string.IsNullOrEmpty(text))
+            return text;
+
+        const string ellipsis = "...";
+        float ellipsisWidth = ImGui.CalcTextSize(ellipsis).X;
+
+        if (maxWidth <= ellipsisWidth)
+            return ellipsis;
+
+        int low = 0;
+        int high = text.Length;
+        string best = ellipsis;
+
+        while (low <= high)
+        {
+            int mid = (low + high) / 2;
+            string candidate = string.Concat(text.AsSpan(0, mid), ellipsis);
+            float width = ImGui.CalcTextSize(candidate).X;
+
+            if (width <= maxWidth)
+            {
+                best = candidate;
+                low = mid + 1;
+            }
+            else
+            {
+                high = mid - 1;
+            }
+        }
+
+        return best;
+    }
 
     private IDalamudTextureWrap? GetIconWrap(uint iconId)
     {

LightlessSync/UI/TopTabMenu.cs

@@ -800,22 +800,9 @@ public class TopTabMenu
         if (!_lightFinderService.IsBroadcasting)
             return "Syncshell Finder";
 
-        string? myHashedCid = null;
-        try
-        {
-            var cid = _dalamudUtilService.GetCID();
-            myHashedCid = cid.ToString().GetHash256();
-        }
-        catch (Exception)
-        {
-            // Couldnt get own CID, log and return default table
-        }
-
         var nearbyCount = _lightFinderScannerService
-            .GetActiveSyncshellBroadcasts()
+            .GetActiveSyncshellBroadcasts(excludeLocal: true)
-            .Where(b =>
+            .Where(b => !string.IsNullOrEmpty(b.GID))
-                !string.IsNullOrEmpty(b.GID) &&
-                !string.Equals(b.HashedCID, myHashedCid, StringComparison.Ordinal))
             .Select(b => b.GID!)
             .Distinct(StringComparer.Ordinal)
             .Count();

LightlessSync/UI/UISharedService.cs

@@ -947,13 +947,16 @@ public partial class UiSharedService : DisposableMediatorSubscriberBase
                 }
             }
 
-            if (_discordOAuthCheck != null && _discordOAuthCheck.IsCompleted)
+            if (_discordOAuthCheck != null && _discordOAuthCheck.IsCompleted && _discordOAuthCheck.Result != null)
             {
-                if (IconTextButton(FontAwesomeIcon.ArrowRight, "Authenticate with Server"))
+                if (_discordOAuthGetCode == null)
                 {
-                    _discordOAuthGetCode = _serverConfigurationManager.GetDiscordOAuthToken(_discordOAuthCheck.Result!, selectedServer.ServerUri, _discordOAuthGetCts.Token);
+                    if (IconTextButton(FontAwesomeIcon.ArrowRight, "Authenticate with Server"))
+                    {
+                        _discordOAuthGetCode = _serverConfigurationManager.GetDiscordOAuthToken(_discordOAuthCheck.Result, selectedServer.ServerUri, _discordOAuthGetCts.Token);
+                    }
                 }
-                else if (_discordOAuthGetCode != null && !_discordOAuthGetCode.IsCompleted)
+                else if (!_discordOAuthGetCode.IsCompleted)
                 {
                     TextWrapped("A browser window has been opened, follow it to authenticate. Click the button below if you accidentally closed the window and need to restart the authentication.");
                     if (IconTextButton(FontAwesomeIcon.Ban, "Cancel Authentication"))
@@ -962,7 +965,7 @@ public partial class UiSharedService : DisposableMediatorSubscriberBase
                         _discordOAuthGetCode = null;
                     }
                 }
-                else if (_discordOAuthGetCode != null && _discordOAuthGetCode.IsCompleted)
+                else
                 {
                     TextWrapped("Discord OAuth is completed, status: ");
                     ImGui.SameLine();

LightlessSync/UI/ZoneChatUi.cs

@@ -11,10 +11,13 @@ using LightlessSync.LightlessConfiguration;
 using LightlessSync.LightlessConfiguration.Models;
 using LightlessSync.Services;
 using LightlessSync.Services.Chat;
+using LightlessSync.Services.LightFinder;
 using LightlessSync.Services.Mediator;
 using LightlessSync.Services.ServerConfiguration;
 using LightlessSync.UI.Services;
+using LightlessSync.UI.Style;
 using LightlessSync.Utils;
+using OtterGui.Text;
 using LightlessSync.WebAPI;
 using LightlessSync.WebAPI.SignalR.Utils;
 using Microsoft.Extensions.Logging;
@@ -29,10 +32,13 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
     private const string ReportPopupId = "Report Message##zone_chat_report_popup";
     private const string ChannelDragPayloadId = "zone_chat_channel_drag";
     private const float DefaultWindowOpacity = .97f;
+    private const float DefaultUnfocusedWindowOpacity = 0.6f;
     private const float MinWindowOpacity = 0.05f;
     private const float MaxWindowOpacity = 1f;
     private const float MinChatFontScale = 0.75f;
     private const float MaxChatFontScale = 1.5f;
+    private const float UnfocusedFadeOutSpeed = 0.22f;
+    private const float FocusFadeInSpeed = 2.0f;
     private const int ReportReasonMaxLength = 500;
     private const int ReportContextMaxLength = 1000;
     private const int MaxChannelNoteTabLength = 25;
@@ -40,6 +46,7 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
     private readonly UiSharedService _uiSharedService;
     private readonly ZoneChatService _zoneChatService;
     private readonly PairUiService _pairUiService;
+    private readonly LightFinderService _lightFinderService;
     private readonly LightlessProfileManager _profileManager;
     private readonly ApiController _apiController;
     private readonly ChatConfigService _chatConfigService;
@@ -49,16 +56,20 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
     private readonly Dictionary<string, string> _draftMessages = new(StringComparer.Ordinal);
     private readonly ImGuiWindowFlags _unpinnedWindowFlags;
     private float _currentWindowOpacity = DefaultWindowOpacity;
+    private float _baseWindowOpacity = DefaultWindowOpacity;
     private bool _isWindowPinned;
     private bool _showRulesOverlay;
     private bool _refocusChatInput;
     private string? _refocusChatInputKey;
+    private bool _isWindowFocused = true;
+    private int _titleBarStylePopCount;
 
     private string? _selectedChannelKey;
     private bool _scrollToBottom = true;
     private float? _pendingChannelScroll;
     private float _channelScroll;
     private float _channelScrollMax;
+    private readonly SeluneBrush _seluneBrush = new();
     private ChatChannelSnapshot? _reportTargetChannel;
     private ChatMessageEntry? _reportTargetMessage;
     private string _reportReason = string.Empty;
@@ -72,6 +83,7 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
     private string? _dragHoverKey;
     private bool _HideStateActive;
     private bool _HideStateWasOpen;
+    private bool _pushedStyle;
 
     public ZoneChatUi(
         ILogger<ZoneChatUi> logger,
@@ -79,6 +91,7 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
         UiSharedService uiSharedService,
         ZoneChatService zoneChatService,
         PairUiService pairUiService,
+        LightFinderService lightFinderService,
         LightlessProfileManager profileManager,
         ChatConfigService chatConfigService,
         ServerConfigurationManager serverConfigurationManager,
@@ -91,6 +104,7 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
         _uiSharedService = uiSharedService;
         _zoneChatService = zoneChatService;
         _pairUiService = pairUiService;
+        _lightFinderService = lightFinderService;
         _profileManager = profileManager;
         _chatConfigService = chatConfigService;
         _serverConfigurationManager = serverConfigurationManager;
@@ -124,8 +138,27 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
     {
         RefreshWindowFlags();
         base.PreDraw();
-        _currentWindowOpacity = Math.Clamp(_chatConfigService.Current.ChatWindowOpacity, MinWindowOpacity, MaxWindowOpacity);
+        var config = _chatConfigService.Current;
+        var baseOpacity = Math.Clamp(config.ChatWindowOpacity, MinWindowOpacity, MaxWindowOpacity);
+        _baseWindowOpacity = baseOpacity;
+        ImGui.PushStyleVar(ImGuiStyleVar.WindowBorderSize, 0);
+        _pushedStyle = true;
+
+        if (config.FadeWhenUnfocused)
+        {
+            var unfocusedOpacity = Math.Clamp(config.UnfocusedWindowOpacity, MinWindowOpacity, MaxWindowOpacity);
+            var targetOpacity = _isWindowFocused ? baseOpacity : Math.Min(baseOpacity, unfocusedOpacity);
+            var delta = ImGui.GetIO().DeltaTime;
+            var speed = _isWindowFocused ? FocusFadeInSpeed : UnfocusedFadeOutSpeed;
+            _currentWindowOpacity = MoveTowards(_currentWindowOpacity, targetOpacity, speed * delta);
+        }
+        else
+        {
+            _currentWindowOpacity = baseOpacity;
+        }
+
         ImGui.SetNextWindowBgAlpha(_currentWindowOpacity);
+        PushTitleBarFadeColors(_currentWindowOpacity);
     }
 
     private void UpdateHideState()
@@ -179,8 +212,30 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
 
     protected override void DrawInternal()
     {
+        var config = _chatConfigService.Current;
+        var isFocused = ImGui.IsWindowFocused(ImGuiFocusedFlags.RootAndChildWindows);
+        var isHovered = ImGui.IsWindowHovered(ImGuiHoveredFlags.RootAndChildWindows);
+        if (config.FadeWhenUnfocused && isHovered && !isFocused)
+        {
+            ImGui.SetWindowFocus();
+        }
+
+        _isWindowFocused = config.FadeWhenUnfocused ? (isFocused || isHovered) : isFocused;
+
+        var contentAlpha = 1f;
+        if (config.FadeWhenUnfocused)
+        {
+            var baseOpacity = MathF.Max(_baseWindowOpacity, 0.001f);
+            contentAlpha = Math.Clamp(_currentWindowOpacity / baseOpacity, 0f, 1f);
+        }
+
+        using var alpha = ImRaii.PushStyle(ImGuiStyleVar.Alpha, contentAlpha);
+        var drawList = ImGui.GetWindowDrawList();
+        var windowPos = ImGui.GetWindowPos();
+        var windowSize = ImGui.GetWindowSize();
+        using var selune = Selune.Begin(_seluneBrush, drawList, windowPos, windowSize);
         var childBgColor = ImGui.GetStyle().Colors[(int)ImGuiCol.ChildBg];
-        childBgColor.W *= _currentWindowOpacity;
+        childBgColor.W *= _baseWindowOpacity;
         using var childBg = ImRaii.PushColor(ImGuiCol.ChildBg, childBgColor);
         DrawConnectionControls();
 
@@ -192,36 +247,58 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
             ImGui.PushStyleColor(ImGuiCol.Text, ImGuiColors.DalamudGrey3);
             ImGui.TextWrapped("No chat channels available.");
             ImGui.PopStyleColor();
-            return;
         }
-
+        else
-        EnsureSelectedChannel(channels);
-        CleanupDrafts(channels);
-
-        DrawChannelButtons(channels);
-
-        if (_selectedChannelKey is null)
-            return;
-
-        var activeChannel = channels.FirstOrDefault(channel => string.Equals(channel.Key, _selectedChannelKey, StringComparison.Ordinal));
-        if (activeChannel.Equals(default(ChatChannelSnapshot)))
         {
-            activeChannel = channels[0];
+            EnsureSelectedChannel(channels);
-            _selectedChannelKey = activeChannel.Key;
+            CleanupDrafts(channels);
+
+            DrawChannelButtons(channels);
+
+            if (_selectedChannelKey is null)
+            {
+                selune.DrawHighlightOnly(ImGui.GetIO().DeltaTime);
+                return;
+            }
+
+            var activeChannel = channels.FirstOrDefault(channel => string.Equals(channel.Key, _selectedChannelKey, StringComparison.Ordinal));
+            if (activeChannel.Equals(default(ChatChannelSnapshot)))
+            {
+                activeChannel = channels[0];
+                _selectedChannelKey = activeChannel.Key;
+            }
+
+            _zoneChatService.SetActiveChannel(activeChannel.Key);
+
+            DrawHeader(activeChannel);
+            ImGui.Separator();
+            DrawMessageArea(activeChannel, _currentWindowOpacity);
+            ImGui.Separator();
+            DrawInput(activeChannel);
         }
 
-        _zoneChatService.SetActiveChannel(activeChannel.Key);
-
-        DrawHeader(activeChannel);
-        ImGui.Separator();
-        DrawMessageArea(activeChannel, _currentWindowOpacity);
-        ImGui.Separator();
-        DrawInput(activeChannel);
-
         if (_showRulesOverlay)
         {
             DrawRulesOverlay();
         }
+
+        selune.DrawHighlightOnly(ImGui.GetIO().DeltaTime);
+    }
+
+    private void PushTitleBarFadeColors(float opacity)
+    {
+        _titleBarStylePopCount = 0;
+        var alpha = Math.Clamp(opacity, 0f, 1f);
+        var colors = ImGui.GetStyle().Colors;
+
+        var titleBg = colors[(int)ImGuiCol.TitleBg];
+        var titleBgActive = colors[(int)ImGuiCol.TitleBgActive];
+        var titleBgCollapsed = colors[(int)ImGuiCol.TitleBgCollapsed];
+
+        ImGui.PushStyleColor(ImGuiCol.TitleBg, new Vector4(titleBg.X, titleBg.Y, titleBg.Z, titleBg.W * alpha));
+        ImGui.PushStyleColor(ImGuiCol.TitleBgActive, new Vector4(titleBgActive.X, titleBgActive.Y, titleBgActive.Z, titleBgActive.W * alpha));
+        ImGui.PushStyleColor(ImGuiCol.TitleBgCollapsed, new Vector4(titleBgCollapsed.X, titleBgCollapsed.Y, titleBgCollapsed.Z, titleBgCollapsed.W * alpha));
+        _titleBarStylePopCount = 3;
     }
 
     private void DrawHeader(ChatChannelSnapshot channel)
@@ -318,52 +395,57 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
         }
         else
         {
-            for (var i = 0; i < channel.Messages.Count; i++)
+            var itemHeight = ImGui.GetTextLineHeightWithSpacing();
+            using var clipper = ImUtf8.ListClipper(channel.Messages.Count, itemHeight);
+            while (clipper.Step())
             {
-                var message = channel.Messages[i];
+                for (var i = clipper.DisplayStart; i < clipper.DisplayEnd; i++)
-                ImGui.PushID(i);
-
-                if (message.IsSystem)
                 {
-                    DrawSystemEntry(message);
+                    var message = channel.Messages[i];
-                    ImGui.PopID();
+                    ImGui.PushID(i);
-                    continue;
-                }
 
-                if (message.Payload is not { } payload)
+                    if (message.IsSystem)
-                {
-                    ImGui.PopID();
-                    continue;
-                }
-
-                var timestampText = string.Empty;
-                if (showTimestamps)
-                {
-                    timestampText = $"[{message.ReceivedAtUtc.ToLocalTime().ToString("HH:mm", CultureInfo.InvariantCulture)}] ";
-                }
-                var color = message.FromSelf ? UIColors.Get("LightlessBlue") : ImGuiColors.DalamudWhite;
-
-                ImGui.PushStyleColor(ImGuiCol.Text, color);
-                ImGui.TextWrapped($"{timestampText}{message.DisplayName}: {payload.Message}");
-                ImGui.PopStyleColor();
-
-                if (ImGui.BeginPopupContextItem($"chat_msg_ctx##{channel.Key}_{i}"))
-                {
-                    var contextLocalTimestamp = payload.SentAtUtc.ToLocalTime();
-                    var contextTimestampText = contextLocalTimestamp.ToString("yyyy-MM-dd HH:mm:ss 'UTC'z", CultureInfo.InvariantCulture);
-                    ImGui.TextDisabled(contextTimestampText);
-                    ImGui.Separator();
-
-                    var actionIndex = 0;
-                    foreach (var action in GetContextMenuActions(channel, message))
                     {
-                        DrawContextMenuAction(action, actionIndex++);
+                        DrawSystemEntry(message);
+                        ImGui.PopID();
+                        continue;
                     }
 
-                    ImGui.EndPopup();
+                    if (message.Payload is not { } payload)
-                }
+                    {
+                        ImGui.PopID();
+                        continue;
+                    }
 
-                ImGui.PopID();
+                    var timestampText = string.Empty;
+                    if (showTimestamps)
+                    {
+                        timestampText = $"[{message.ReceivedAtUtc.ToLocalTime().ToString("HH:mm", CultureInfo.InvariantCulture)}] ";
+                    }
+                    var color = message.FromSelf ? UIColors.Get("LightlessBlue") : ImGuiColors.DalamudWhite;
+
+                    ImGui.PushStyleColor(ImGuiCol.Text, color);
+                    ImGui.TextWrapped($"{timestampText}{message.DisplayName}: {payload.Message}");
+                    ImGui.PopStyleColor();
+
+                    if (ImGui.BeginPopupContextItem($"chat_msg_ctx##{channel.Key}_{i}"))
+                    {
+                        var contextLocalTimestamp = payload.SentAtUtc.ToLocalTime();
+                        var contextTimestampText = contextLocalTimestamp.ToString("yyyy-MM-dd HH:mm:ss 'UTC'z", CultureInfo.InvariantCulture);
+                        ImGui.TextDisabled(contextTimestampText);
+                        ImGui.Separator();
+
+                        var actionIndex = 0;
+                        foreach (var action in GetContextMenuActions(channel, message))
+                        {
+                            DrawContextMenuAction(action, actionIndex++);
+                        }
+
+                        ImGui.EndPopup();
+                    }
+
+                    ImGui.PopID();
+                }
             }
         }
 
@@ -744,6 +826,21 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
         ImGui.EndPopup();
     }
 
+    public override void PostDraw()
+    {
+        if (_pushedStyle)
+        {
+            ImGui.PopStyleVar(1);
+            _pushedStyle = false;
+        }
+        if (_titleBarStylePopCount > 0)
+        {
+            ImGui.PopStyleColor(_titleBarStylePopCount);
+            _titleBarStylePopCount = 0;
+        }
+        base.PostDraw();
+    }
+
     private void OpenReportPopup(ChatChannelSnapshot channel, ChatMessageEntry message)
     {
         if (message.Payload is not { } payload)
@@ -1119,18 +1216,56 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
         var groupSize = ImGui.GetItemRectSize();
         var minBlockX = cursorStart.X + groupSize.X + style.ItemSpacing.X;
         var availableAfterGroup = contentRightX - (cursorStart.X + groupSize.X);
+        var lightfinderButtonWidth = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.PersonCirclePlus).X;
         var settingsButtonWidth = _uiSharedService.GetIconButtonSize(FontAwesomeIcon.Cog).X;
         var pinIcon = _isWindowPinned ? FontAwesomeIcon.Lock : FontAwesomeIcon.Unlock;
         var pinButtonWidth = _uiSharedService.GetIconButtonSize(pinIcon).X;
-        var blockWidth = rulesButtonWidth + style.ItemSpacing.X + settingsButtonWidth + style.ItemSpacing.X + pinButtonWidth;
+        var blockWidth = lightfinderButtonWidth + style.ItemSpacing.X + rulesButtonWidth + style.ItemSpacing.X + settingsButtonWidth + style.ItemSpacing.X + pinButtonWidth;
         var desiredBlockX = availableAfterGroup > blockWidth + style.ItemSpacing.X
             ? contentRightX - blockWidth
             : minBlockX;
         desiredBlockX = Math.Max(cursorStart.X, desiredBlockX);
-        var rulesPos = new Vector2(desiredBlockX, cursorStart.Y);
+        var lightfinderPos = new Vector2(desiredBlockX, cursorStart.Y);
-        var settingsPos = new Vector2(desiredBlockX + rulesButtonWidth + style.ItemSpacing.X, cursorStart.Y);
+        var rulesPos = new Vector2(lightfinderPos.X + lightfinderButtonWidth + style.ItemSpacing.X, cursorStart.Y);
+        var settingsPos = new Vector2(rulesPos.X + rulesButtonWidth + style.ItemSpacing.X, cursorStart.Y);
         var pinPos = new Vector2(settingsPos.X + settingsButtonWidth + style.ItemSpacing.X, cursorStart.Y);
 
+        ImGui.SameLine();
+        ImGui.SetCursorPos(lightfinderPos);
+        var lightfinderEnabled = _lightFinderService.IsBroadcasting;
+        var lightfinderColor = lightfinderEnabled ? UIColors.Get("LightlessGreen") : ImGuiColors.DalamudGrey3;
+        var lightfinderButtonSize = new Vector2(lightfinderButtonWidth, ImGui.GetFrameHeight());
+        ImGui.InvisibleButton("zone_chat_lightfinder_button", lightfinderButtonSize);
+        var lightfinderMin = ImGui.GetItemRectMin();
+        var lightfinderMax = ImGui.GetItemRectMax();
+        var iconSize = _uiSharedService.GetIconSize(FontAwesomeIcon.PersonCirclePlus);
+        var iconPos = new Vector2(
+            lightfinderMin.X + (lightfinderButtonSize.X - iconSize.X) * 0.5f,
+            lightfinderMin.Y + (lightfinderButtonSize.Y - iconSize.Y) * 0.5f);
+        using (_uiSharedService.IconFont.Push())
+        {
+            ImGui.GetWindowDrawList().AddText(iconPos, ImGui.GetColorU32(lightfinderColor), FontAwesomeIcon.PersonCirclePlus.ToIconString());
+        }
+
+        if (ImGui.IsItemClicked())
+        {
+            Mediator.Publish(new UiToggleMessage(typeof(LightFinderUI)));
+        }
+        if (ImGui.IsItemHovered())
+        {
+            var padding = new Vector2(8f * ImGuiHelpers.GlobalScale);
+            Selune.RegisterHighlight(
+                lightfinderMin - padding,
+                lightfinderMax + padding,
+                SeluneHighlightMode.Point,
+                exactSize: true,
+                clipToElement: true,
+                clipPadding: padding,
+                highlightColorOverride: lightfinderColor,
+                highlightAlphaOverride: 0.2f);
+            ImGui.SetTooltip("If Lightfinder is enabled, you will be able to see the character names of other Lightfinder users in the same zone when they send a message.");
+        }
+
         ImGui.SameLine();
         ImGui.SetCursorPos(rulesPos);
         if (ImGui.Button("Rules", new Vector2(rulesButtonWidth, 0f)))
@@ -1376,9 +1511,55 @@ public sealed class ZoneChatUi : WindowMediatorSubscriberBase
             ImGui.SetTooltip("Adjust chat window transparency.\nRight-click to reset to default.");
         }
 
+        var fadeUnfocused = chatConfig.FadeWhenUnfocused;
+        if (ImGui.Checkbox("Fade window when unfocused", ref fadeUnfocused))
+        {
+            chatConfig.FadeWhenUnfocused = fadeUnfocused;
+            _chatConfigService.Save();
+        }
+        if (ImGui.IsItemHovered())
+        {
+            ImGui.SetTooltip("When enabled, the chat window fades after it loses focus.\nHovering the window restores focus.");
+        }
+
+        ImGui.BeginDisabled(!fadeUnfocused);
+        var unfocusedOpacity = Math.Clamp(chatConfig.UnfocusedWindowOpacity, MinWindowOpacity, MaxWindowOpacity);
+        var unfocusedChanged = ImGui.SliderFloat("Unfocused transparency", ref unfocusedOpacity, MinWindowOpacity, MaxWindowOpacity, "%.2f");
+        var resetUnfocused = ImGui.IsItemClicked(ImGuiMouseButton.Right);
+        if (resetUnfocused)
+        {
+            unfocusedOpacity = DefaultUnfocusedWindowOpacity;
+            unfocusedChanged = true;
+        }
+        if (unfocusedChanged)
+        {
+            chatConfig.UnfocusedWindowOpacity = unfocusedOpacity;
+            _chatConfigService.Save();
+        }
+        if (ImGui.IsItemHovered())
+        {
+            ImGui.SetTooltip("Target transparency while the chat window is unfocused.\nRight-click to reset to default.");
+        }
+        ImGui.EndDisabled();
+
         ImGui.EndPopup();
     }
 
+    private static float MoveTowards(float current, float target, float maxDelta)
+    {
+        if (current < target)
+        {
+            return MathF.Min(current + maxDelta, target);
+        }
+
+        if (current > target)
+        {
+            return MathF.Max(current - maxDelta, target);
+        }
+
+        return target;
+    }
+
     private void ToggleChatConnection(bool currentlyEnabled)
     {
         _ = Task.Run(async () =>

LightlessSync/Utils/VariousExtensions.cs

@@ -60,16 +60,6 @@ public static class VariousExtensions
         CharacterData? oldData, ILogger logger, IPairPerformanceSubject cachedPlayer, bool forceApplyCustomization, bool forceApplyMods)
     {
         oldData ??= new();
-        static bool FileReplacementsEquivalent(ICollection<FileReplacementData> left, ICollection<FileReplacementData> right)
-        {
-            if (left.Count != right.Count)
-            {
-                return false;
-            }
-
-            var comparer = LightlessSync.PlayerData.Data.FileReplacementDataComparer.Instance;
-            return !left.Except(right, comparer).Any() && !right.Except(left, comparer).Any();
-        }
 
         var charaDataToUpdate = new Dictionary<ObjectKind, HashSet<PlayerChanges>>();
         foreach (ObjectKind objectKind in Enum.GetValues<ObjectKind>())
@@ -105,7 +95,7 @@ public static class VariousExtensions
                 {
                     var oldList = oldData.FileReplacements[objectKind];
                     var newList = newData.FileReplacements[objectKind];
-                    var listsAreEqual = FileReplacementsEquivalent(oldList, newList);
+                    var listsAreEqual = oldList.SequenceEqual(newList, PlayerData.Data.FileReplacementDataComparer.Instance);
                     if (!listsAreEqual || forceApplyMods)
                     {
                         logger.LogDebug("[BASE-{appBase}] Updating {object}/{kind} (FileReplacements not equal) => {change}", applicationBase, cachedPlayer, objectKind, PlayerChanges.ModFiles);
@@ -128,9 +118,9 @@ public static class VariousExtensions
                                 .OrderBy(g => string.IsNullOrEmpty(g.Hash) ? g.FileSwapPath : g.Hash, StringComparer.OrdinalIgnoreCase).ToList();
                             var newTail = newFileReplacements.Where(g => g.GamePaths.Any(p => p.Contains("/tail/", StringComparison.OrdinalIgnoreCase)))
                                 .OrderBy(g => string.IsNullOrEmpty(g.Hash) ? g.FileSwapPath : g.Hash, StringComparer.OrdinalIgnoreCase).ToList();
-                            var existingTransients = existingFileReplacements.Where(g => g.GamePaths.Any(g => !g.EndsWith("mdl", StringComparison.OrdinalIgnoreCase) && !g.EndsWith("tex", StringComparison.OrdinalIgnoreCase) && !g.EndsWith("mtrl", StringComparison.OrdinalIgnoreCase)))
+                            var existingTransients = existingFileReplacements.Where(g => g.GamePaths.Any(g => !g.EndsWith("mdl") && !g.EndsWith("tex") && !g.EndsWith("mtrl")))
                                 .OrderBy(g => string.IsNullOrEmpty(g.Hash) ? g.FileSwapPath : g.Hash, StringComparer.OrdinalIgnoreCase).ToList();
-                            var newTransients = newFileReplacements.Where(g => g.GamePaths.Any(g => !g.EndsWith("mdl", StringComparison.OrdinalIgnoreCase) && !g.EndsWith("tex", StringComparison.OrdinalIgnoreCase) && !g.EndsWith("mtrl", StringComparison.OrdinalIgnoreCase)))
+                            var newTransients = newFileReplacements.Where(g => g.GamePaths.Any(g => !g.EndsWith("mdl") && !g.EndsWith("tex") && !g.EndsWith("mtrl")))
                                 .OrderBy(g => string.IsNullOrEmpty(g.Hash) ? g.FileSwapPath : g.Hash, StringComparer.OrdinalIgnoreCase).ToList();
 
                             logger.LogTrace("[BASE-{appbase}] ExistingFace: {of}, NewFace: {fc}; ExistingHair: {eh}, NewHair: {nh}; ExistingTail: {et}, NewTail: {nt}; ExistingTransient: {etr}, NewTransient: {ntr}", applicationBase,
@@ -177,8 +167,7 @@ public static class VariousExtensions
             if (objectKind != ObjectKind.Player) continue;
 
             bool manipDataDifferent = !string.Equals(oldData.ManipulationData, newData.ManipulationData, StringComparison.Ordinal);
-            var hasManipulationData = !string.IsNullOrEmpty(newData.ManipulationData);
+            if (manipDataDifferent || forceApplyMods)
-            if (manipDataDifferent || (forceApplyMods && hasManipulationData))
             {
                 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

@@ -563,7 +563,7 @@ public partial class FileDownloadManager : DisposableMediatorSubscriberBase
 
         if (directDownloads.Count > 0 || downloadBatches.Length > 0)
         {
-            Logger.LogWarning("Downloading {direct} files directly, and {batchtotal} in {batches} batches.", directDownloads.Count, batchDownloads.Count, downloadBatches.Length);
+            Logger.LogInformation("Downloading {direct} files directly, and {batchtotal} in {batches} batches.", directDownloads.Count, batchDownloads.Count, downloadBatches.Length);
         }
 
         if (gameObjectHandler is not null)

LightlessSync/WebAPI/SignalR/ApiController.cs

@@ -418,7 +418,7 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL
 
     public Task CyclePauseAsync(PairUniqueIdentifier ident)
     {
-        var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(8));
+        var timeoutCts = new CancellationTokenSource(TimeSpan.FromSeconds(5));
         _ = Task.Run(async () =>
         {
             var token = timeoutCts.Token;
@@ -430,20 +430,19 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL
                     return;
                 }
 
-                var originalPermissions = entry.SelfPermissions;
+                var targetPermissions = entry.SelfPermissions;
-                var targetPermissions = originalPermissions;
+                targetPermissions.SetPaused(paused: true);
-                targetPermissions.SetPaused(!originalPermissions.IsPaused());
 
                 await UserSetPairPermissions(new UserPermissionsDto(entry.User, targetPermissions)).ConfigureAwait(false);
 
-                var applied = false;
+                var pauseApplied = false;
                 while (!token.IsCancellationRequested)
                 {
                     if (_pairCoordinator.Ledger.TryGetEntry(ident, out var updated) && updated is not null)
                     {
                         if (updated.SelfPermissions == targetPermissions)
                         {
-                            applied = true;
+                            pauseApplied = true;
                             entry = updated;
                             break;
                         }
@@ -453,13 +452,16 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL
                     Logger.LogTrace("Waiting for permissions change for {uid}", ident.UserId);
                 }
 
-                if (!applied)
+                if (!pauseApplied)
                 {
                     Logger.LogWarning("CyclePauseAsync timed out waiting for pause acknowledgement for {uid}", ident.UserId);
                     return;
                 }
 
-                Logger.LogDebug("CyclePauseAsync toggled paused for {uid} to {state}", ident.UserId, targetPermissions.IsPaused());
+                targetPermissions.SetPaused(paused: false);
+                await UserSetPairPermissions(new UserPermissionsDto(entry.User, targetPermissions)).ConfigureAwait(false);
+
+                Logger.LogDebug("CyclePauseAsync completed pause cycle for {uid}", ident.UserId);
             }
             catch (OperationCanceledException)
             {
@@ -479,16 +481,26 @@ public sealed partial class ApiController : DisposableMediatorSubscriberBase, IL
     }
 
     public async Task PauseAsync(UserData userData)
+    {
+        await SetPausedStateAsync(userData, paused: true).ConfigureAwait(false);
+    }
+
+    public async Task UnpauseAsync(UserData userData)
+    {
+        await SetPausedStateAsync(userData, paused: false).ConfigureAwait(false);
+    }
+
+    private async Task SetPausedStateAsync(UserData userData, bool paused)
     {
         var pairIdent = new PairUniqueIdentifier(userData.UID);
         if (!_pairCoordinator.Ledger.TryGetEntry(pairIdent, out var entry) || entry is null)
         {
-            Logger.LogWarning("PauseAsync: pair {uid} not found in ledger", userData.UID);
+            Logger.LogWarning("SetPausedStateAsync: pair {uid} not found in ledger", userData.UID);
             return;
         }
 
         var permissions = entry.SelfPermissions;
-        permissions.SetPaused(paused: true);
+        permissions.SetPaused(paused);
         await UserSetPairPermissions(new UserPermissionsDto(userData, permissions)).ConfigureAwait(false);
     }