init 2

LightlessSync/PlayerData/Pairs/IPairPerformanceSubject.cs

@@ -0,0 +1,16 @@
+using LightlessSync.API.Data;
+
+namespace LightlessSync.PlayerData.Pairs;
+
+public interface IPairPerformanceSubject
+{
+    string Ident { get; }
+    string PlayerName { get; }
+    UserData UserData { get; }
+    bool IsPaused { get; }
+    bool IsDirectlyPaired { get; }
+    bool HasStickyPermissions { get; }
+    long LastAppliedApproximateVRAMBytes { get; set; }
+    long LastAppliedApproximateEffectiveVRAMBytes { get; set; }
+    long LastAppliedDataTris { get; set; }
+}

LightlessSync/PlayerData/Pairs/Pair.cs

@@ -1,103 +1,133 @@
-using Dalamud.Game.Gui.ContextMenu;
+using System;
+using System.Linq;
+using Dalamud.Game.Gui.ContextMenu;
 using Dalamud.Game.Text.SeStringHandling;
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Data.Extensions;
 using LightlessSync.API.Dto.User;
-using LightlessSync.PlayerData.Factories;
-using LightlessSync.PlayerData.Handlers;
+using LightlessSync.PlayerData.Pairs;
 using LightlessSync.Services.Mediator;
 using LightlessSync.Services.ServerConfiguration;
-using LightlessSync.Utils;
 using Microsoft.Extensions.Logging;
+using LightlessSync.WebAPI;
 
 namespace LightlessSync.PlayerData.Pairs;
 
 public class Pair
 {
-    private readonly PairHandlerFactory _cachedPlayerFactory;
-    private readonly SemaphoreSlim _creationSemaphore = new(1);
+    private readonly PairLedger _pairLedger;
     private readonly ILogger<Pair> _logger;
     private readonly LightlessMediator _mediator;
     private readonly ServerConfigurationManager _serverConfigurationManager;
-    private CancellationTokenSource _applicationCts = new();
-    private OnlineUserIdentDto? _onlineUserIdentDto = null;
+    private readonly Lazy<ApiController> _apiController;
 
-    public Pair(ILogger<Pair> logger, UserFullPairDto userPair, PairHandlerFactory cachedPlayerFactory,
-        LightlessMediator mediator, ServerConfigurationManager serverConfigurationManager)
+    public Pair(
+        ILogger<Pair> logger,
+        UserFullPairDto userPair,
+        PairLedger pairLedger,
+        LightlessMediator mediator,
+        ServerConfigurationManager serverConfigurationManager,
+        Lazy<ApiController> apiController)
     {
         _logger = logger;
         UserPair = userPair;
-        _cachedPlayerFactory = cachedPlayerFactory;
+        _pairLedger = pairLedger;
         _mediator = mediator;
         _serverConfigurationManager = serverConfigurationManager;
+        _apiController = apiController;
     }
 
-    public bool HasCachedPlayer => CachedPlayer != null && !string.IsNullOrEmpty(CachedPlayer.PlayerName) && _onlineUserIdentDto != null;
+    private PairUniqueIdentifier PairIdent => UniqueIdent;
+
+    private IPairHandlerAdapter? TryGetHandler()
+    {
+        return _pairLedger.GetHandler(PairIdent);
+    }
+
+    private PairConnection? TryGetConnection()
+    {
+        return _pairLedger.TryGetEntry(PairIdent, out var entry) && entry is not null
+            ? entry.Connection
+            : null;
+    }
+
+    public bool HasCachedPlayer => TryGetHandler() is not null;
     public IndividualPairStatus IndividualPairStatus => UserPair.IndividualPairStatus;
     public bool IsDirectlyPaired => IndividualPairStatus != IndividualPairStatus.None;
     public bool IsOneSidedPair => IndividualPairStatus == IndividualPairStatus.OneSided;
-    public bool IsOnline => CachedPlayer != null;
+
+    public bool IsOnline => TryGetConnection()?.IsOnline ?? false;
 
     public bool IsPaired => IndividualPairStatus == IndividualPairStatus.Bidirectional || UserPair.Groups.Any();
     public bool IsPaused => UserPair.OwnPermissions.IsPaused();
-    public bool IsVisible => CachedPlayer?.IsVisible ?? false;
-    public CharacterData? LastReceivedCharacterData { get; set; }
-    public string? PlayerName => CachedPlayer?.PlayerName ?? string.Empty;
-    public long LastAppliedDataBytes => CachedPlayer?.LastAppliedDataBytes ?? -1;
-    public long LastAppliedDataTris { get; set; } = -1;
-    public long LastAppliedApproximateVRAMBytes { get; set; } = -1;
-    public string Ident => _onlineUserIdentDto?.Ident ?? string.Empty;
-    public uint PlayerCharacterId => CachedPlayer?.PlayerCharacterId ?? uint.MaxValue;
+    public bool IsVisible => _pairLedger.IsPairVisible(PairIdent);
+    public CharacterData? LastReceivedCharacterData => TryGetHandler()?.LastReceivedCharacterData;
+    public string? PlayerName => TryGetHandler()?.PlayerName ?? UserPair.User.AliasOrUID;
+    public long LastAppliedDataBytes => TryGetHandler()?.LastAppliedDataBytes ?? -1;
+    public long LastAppliedDataTris => TryGetHandler()?.LastAppliedDataTris ?? -1;
+    public long LastAppliedApproximateVRAMBytes => TryGetHandler()?.LastAppliedApproximateVRAMBytes ?? -1;
+    public long LastAppliedApproximateEffectiveVRAMBytes => TryGetHandler()?.LastAppliedApproximateEffectiveVRAMBytes ?? -1;
+    public string Ident => TryGetHandler()?.Ident ?? TryGetConnection()?.Ident ?? string.Empty;
+    public uint PlayerCharacterId => TryGetHandler()?.PlayerCharacterId ?? uint.MaxValue;
+    public PairUniqueIdentifier UniqueIdent => new(UserData.UID);
 
     public UserData UserData => UserPair.User;
 
     public UserFullPairDto UserPair { get; set; }
-    private PairHandler? CachedPlayer { get; set; }
 
     public void AddContextMenu(IMenuOpenedArgs args)
     {
-        if (CachedPlayer == null || (args.Target is not MenuTargetDefault target) || target.TargetObjectId != CachedPlayer.PlayerCharacterId || IsPaused) return;
+        var handler = TryGetHandler();
+        if (handler is null)
+        {
+            return;
+        }
 
-        SeStringBuilder seStringBuilder = new();
-        SeStringBuilder seStringBuilder2 = new();
-        SeStringBuilder seStringBuilder3 = new();
-        SeStringBuilder seStringBuilder4 = new();
-        var openProfileSeString = seStringBuilder.AddText("Open Profile").Build();
-        var reapplyDataSeString = seStringBuilder2.AddText("Reapply last data").Build();
-        var cyclePauseState = seStringBuilder3.AddText("Cycle pause state").Build();
-        var changePermissions = seStringBuilder4.AddText("Change Permissions").Build();
-        args.AddMenuItem(new MenuItem()
+        if (args.Target is not MenuTargetDefault target || target.TargetObjectId != handler.PlayerCharacterId || IsPaused)
+        {
+            return;
+        }
+
+        var openProfileSeString = new SeStringBuilder().AddText("Open Profile").Build();
+        var reapplyDataSeString = new SeStringBuilder().AddText("Reapply last data").Build();
+        var cyclePauseState = new SeStringBuilder().AddText("Cycle pause state").Build();
+        var changePermissions = new SeStringBuilder().AddText("Change Permissions").Build();
+
+        args.AddMenuItem(new MenuItem
         {
             Name = openProfileSeString,
-            OnClicked = (a) => _mediator.Publish(new ProfileOpenStandaloneMessage(this)),
+            OnClicked = _ => _mediator.Publish(new ProfileOpenStandaloneMessage(this)),
             UseDefaultPrefix = false,
             PrefixChar = 'L',
             PrefixColor = 708
         });
 
-        args.AddMenuItem(new MenuItem()
+        args.AddMenuItem(new MenuItem
         {
             Name = reapplyDataSeString,
-            OnClicked = (a) => ApplyLastReceivedData(forced: true),
+            OnClicked = _ => ApplyLastReceivedData(forced: true),
             UseDefaultPrefix = false,
             PrefixChar = 'L',
             PrefixColor = 708
         });
 
-        args.AddMenuItem(new MenuItem()
+        args.AddMenuItem(new MenuItem
         {
             Name = changePermissions,
-            OnClicked = (a) => _mediator.Publish(new OpenPermissionWindow(this)),
+            OnClicked = _ => _mediator.Publish(new OpenPermissionWindow(this)),
             UseDefaultPrefix = false,
             PrefixChar = 'L',
             PrefixColor = 708
         });
 
-        args.AddMenuItem(new MenuItem()
+        args.AddMenuItem(new MenuItem
         {
             Name = cyclePauseState,
-            OnClicked = (a) => _mediator.Publish(new CyclePauseMessage(UserData)),
+            OnClicked = _ =>
+            {
+                TriggerCyclePause();
+            },
             UseDefaultPrefix = false,
             PrefixChar = 'L',
             PrefixColor = 708
@@ -106,68 +136,38 @@ public class Pair
 
     public void ApplyData(OnlineUserCharaDataDto data)
     {
-        _applicationCts = _applicationCts.CancelRecreate();
-        LastReceivedCharacterData = data.CharaData;
+        _logger.LogTrace("Character data received for {Uid}; handler will process via registry.", UserData.UID);
+    }
 
-        if (CachedPlayer == null)
-        {
-            _logger.LogDebug("Received Data for {uid} but CachedPlayer does not exist, waiting", data.User.UID);
-            _ = Task.Run(async () =>
-            {
-                using var timeoutCts = new CancellationTokenSource();
-                timeoutCts.CancelAfter(TimeSpan.FromSeconds(120));
-                var appToken = _applicationCts.Token;
-                using var combined = CancellationTokenSource.CreateLinkedTokenSource(timeoutCts.Token, appToken);
-                while (CachedPlayer == null && !combined.Token.IsCancellationRequested)
-                {
-                    await Task.Delay(250, combined.Token).ConfigureAwait(false);
-                }
-
-                if (!combined.IsCancellationRequested)
-                {
-                    _logger.LogDebug("Applying delayed data for {uid}", data.User.UID);
-                    ApplyLastReceivedData();
-                }
-            });
-            return;
-        }
-
-        ApplyLastReceivedData();
+    private void TriggerCyclePause()
+    {
+        _ = _apiController.Value.CyclePauseAsync(this);
     }
 
     public void ApplyLastReceivedData(bool forced = false)
     {
-        if (CachedPlayer == null) return;
-        if (LastReceivedCharacterData == null) return;
+        var handler = TryGetHandler();
+        if (handler is null)
+        {
+            _logger.LogTrace("ApplyLastReceivedData skipped for {Uid}: handler missing.", UserData.UID);
+            return;
+        }
 
-        CachedPlayer.ApplyCharacterData(Guid.NewGuid(), RemoveNotSyncedFiles(LastReceivedCharacterData.DeepClone())!, forced);
+        handler.ApplyLastReceivedData(forced);
     }
 
     public void CreateCachedPlayer(OnlineUserIdentDto? dto = null)
     {
-        try
+        var handler = TryGetHandler();
+        if (handler is null)
         {
-            _creationSemaphore.Wait();
-
-            if (CachedPlayer != null) return;
-
-            if (dto == null && _onlineUserIdentDto == null)
-            {
-                CachedPlayer?.Dispose();
-                CachedPlayer = null;
-                return;
-            }
-            if (dto != null)
-            {
-                _onlineUserIdentDto = dto;
-            }
-
-            CachedPlayer?.Dispose();
-            CachedPlayer = _cachedPlayerFactory.Create(this);
+            _logger.LogTrace("CreateCachedPlayer skipped for {Uid}: handler unavailable.", UserData.UID);
+            return;
         }
-        finally
+
+        if (!handler.Initialized)
         {
-            _creationSemaphore.Release();
+            handler.Initialize();
         }
     }
 
@@ -178,7 +178,7 @@ public class Pair
 
     public string GetPlayerNameHash()
     {
-        return CachedPlayer?.PlayerNameHash ?? string.Empty;
+        return TryGetHandler()?.PlayerNameHash ?? string.Empty;
     }
 
     public bool HasAnyConnection()
@@ -188,21 +188,7 @@ public class Pair
 
     public void MarkOffline(bool wait = true)
     {
-        try
-        {
-            if (wait)
-                _creationSemaphore.Wait();
-            LastReceivedCharacterData = null;
-            var player = CachedPlayer;
-            CachedPlayer = null;
-            player?.Dispose();
-            _onlineUserIdentDto = null;
-        }
-        finally
-        {
-            if (wait)
-                _creationSemaphore.Release();
-        }
+        _logger.LogTrace("MarkOffline invoked for {Uid} (wait: {Wait}). New registry handles handler disposal.", UserData.UID, wait);
     }
 
     public void SetNote(string note)
@@ -212,47 +198,12 @@ public class Pair
 
     internal void SetIsUploading()
     {
-        CachedPlayer?.SetUploading();
-    }
-
-    private CharacterData? RemoveNotSyncedFiles(CharacterData? data)
-    {
-        _logger.LogTrace("Removing not synced files");
-        if (data == null)
+        var handler = TryGetHandler();
+        if (handler is null)
         {
-            _logger.LogTrace("Nothing to remove");
-            return data;
+            return;
         }
 
-        bool disableIndividualAnimations = (UserPair.OtherPermissions.IsDisableAnimations() || UserPair.OwnPermissions.IsDisableAnimations());
-        bool disableIndividualVFX = (UserPair.OtherPermissions.IsDisableVFX() || UserPair.OwnPermissions.IsDisableVFX());
-        bool disableIndividualSounds = (UserPair.OtherPermissions.IsDisableSounds() || UserPair.OwnPermissions.IsDisableSounds());
-
-        _logger.LogTrace("Disable: Sounds: {disableIndividualSounds}, Anims: {disableIndividualAnims}; " +
-            "VFX: {disableGroupSounds}",
-            disableIndividualSounds, disableIndividualAnimations, disableIndividualVFX);
-
-        if (disableIndividualAnimations || disableIndividualSounds || disableIndividualVFX)
-        {
-            _logger.LogTrace("Data cleaned up: Animations disabled: {disableAnimations}, Sounds disabled: {disableSounds}, VFX disabled: {disableVFX}",
-                disableIndividualAnimations, disableIndividualSounds, disableIndividualVFX);
-            foreach (var objectKind in data.FileReplacements.Select(k => k.Key))
-            {
-                if (disableIndividualSounds)
-                    data.FileReplacements[objectKind] = data.FileReplacements[objectKind]
-                        .Where(f => !f.GamePaths.Any(p => p.EndsWith("scd", StringComparison.OrdinalIgnoreCase)))
-                        .ToList();
-                if (disableIndividualAnimations)
-                    data.FileReplacements[objectKind] = data.FileReplacements[objectKind]
-                        .Where(f => !f.GamePaths.Any(p => p.EndsWith("tmb", StringComparison.OrdinalIgnoreCase) || p.EndsWith("pap", StringComparison.OrdinalIgnoreCase)))
-                        .ToList();
-                if (disableIndividualVFX)
-                    data.FileReplacements[objectKind] = data.FileReplacements[objectKind]
-                        .Where(f => !f.GamePaths.Any(p => p.EndsWith("atex", StringComparison.OrdinalIgnoreCase) || p.EndsWith("avfx", StringComparison.OrdinalIgnoreCase)))
-                        .ToList();
-            }
-        }
-
-        return data;
+        handler.SetUploading(true);
     }
-}
+}

LightlessSync/PlayerData/Pairs/PairCoordinator.cs

@@ -0,0 +1,553 @@
+using System;
+using System.Collections.Concurrent;
+using LightlessSync.API.Data;
+using LightlessSync.API.Data.Enum;
+using LightlessSync.API.Data.Extensions;
+using LightlessSync.API.Dto.CharaData;
+using LightlessSync.API.Dto.Group;
+using LightlessSync.API.Dto.User;
+using LightlessSync.LightlessConfiguration;
+using LightlessSync.LightlessConfiguration.Models;
+using LightlessSync.Services.Mediator;
+using LightlessSync.Services.Events;
+using LightlessSync.Services.ServerConfiguration;
+using Microsoft.Extensions.Logging;
+
+namespace LightlessSync.PlayerData.Pairs;
+
+public sealed class PairCoordinator : MediatorSubscriberBase
+{
+    private readonly ILogger<PairCoordinator> _logger;
+    private readonly LightlessConfigService _configService;
+    private readonly LightlessMediator _mediator;
+    private readonly PairHandlerRegistry _handlerRegistry;
+    private readonly PairManager _pairManager;
+    private readonly PairLedger _pairLedger;
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+    private readonly ConcurrentDictionary<string, OnlineUserCharaDataDto> _pendingCharacterData = new(StringComparer.Ordinal);
+
+    public PairCoordinator(
+        ILogger<PairCoordinator> logger,
+        LightlessConfigService configService,
+        LightlessMediator mediator,
+        PairHandlerRegistry handlerRegistry,
+        PairManager pairManager,
+        PairLedger pairLedger,
+        ServerConfigurationManager serverConfigurationManager)
+        : base(logger, mediator)
+    {
+        _logger = logger;
+        _configService = configService;
+        _mediator = mediator;
+        _handlerRegistry = handlerRegistry;
+        _pairManager = pairManager;
+        _pairLedger = pairLedger;
+        _serverConfigurationManager = serverConfigurationManager;
+
+        mediator.Subscribe<ActiveServerChangedMessage>(this, msg => HandleActiveServerChange(msg.ServerUrl));
+        mediator.Subscribe<DisconnectedMessage>(this, _ => HandleDisconnected());
+    }
+
+    internal PairLedger Ledger => _pairLedger;
+
+    private void PublishPairDataChanged(bool groupChanged = false)
+    {
+        _mediator.Publish(new RefreshUiMessage());
+        _mediator.Publish(new PairDataChangedMessage());
+        if (groupChanged)
+        {
+            _mediator.Publish(new GroupCollectionChangedMessage());
+        }
+    }
+
+    private void NotifyUserOnline(PairConnection? connection, bool sendNotification)
+    {
+        if (connection is null)
+        {
+            return;
+        }
+
+        var config = _configService.Current;
+        if (config.ShowOnlineNotifications && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Pair {Uid} marked online", connection.User.UID);
+        }
+
+        if (!sendNotification || !config.ShowOnlineNotifications)
+        {
+            return;
+        }
+
+        if (config.ShowOnlineNotificationsOnlyForIndividualPairs &&
+            (!connection.IsDirectlyPaired || connection.IsOneSided))
+        {
+            return;
+        }
+
+        var note = _serverConfigurationManager.GetNoteForUid(connection.User.UID);
+        if (config.ShowOnlineNotificationsOnlyForNamedPairs &&
+            string.IsNullOrEmpty(note))
+        {
+            return;
+        }
+
+        var message = !string.IsNullOrEmpty(note)
+            ? $"{note} ({connection.User.AliasOrUID}) is now online"
+            : $"{connection.User.AliasOrUID} is now online";
+
+        _mediator.Publish(new NotificationMessage("User online", message, NotificationType.Info, TimeSpan.FromSeconds(5)));
+    }
+
+    private void ReapplyLastKnownData(string userId, string ident, bool forced = false)
+    {
+        var result = _handlerRegistry.ApplyLastReceivedData(new PairUniqueIdentifier(userId), ident, forced);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to reapply cached data for {Uid}: {Error}", userId, result.Error);
+        }
+    }
+
+    public void HandleGroupChangePermissions(GroupPermissionDto dto)
+    {
+        var result = _pairManager.UpdateGroupPermissions(dto);
+        if (!result.Success)
+        {
+            if (_logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("Failed to update permissions for group {GroupId}: {Error}", dto.Group.GID, result.Error);
+            }
+            return;
+        }
+
+        PublishPairDataChanged(groupChanged: true);
+    }
+
+    public void HandleGroupFullInfo(GroupFullInfoDto dto)
+    {
+        var result = _pairManager.AddGroup(dto);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to add group {GroupId}: {Error}", dto.Group.GID, result.Error);
+            return;
+        }
+
+        PublishPairDataChanged(groupChanged: true);
+    }
+
+    public void HandleGroupPairJoined(GroupPairFullInfoDto dto)
+    {
+        var result = _pairManager.AddOrUpdateGroupPair(dto);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to add group pair {Uid}/{Group}: {Error}", dto.User.UID, dto.Group.GID, result.Error);
+            return;
+        }
+
+        PublishPairDataChanged(groupChanged: true);
+    }
+
+    private void HandleActiveServerChange(string serverUrl)
+    {
+        if (_logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Active server changed to {Server}", serverUrl);
+        }
+
+        ResetPairState();
+    }
+
+    private void HandleDisconnected()
+    {
+        if (_logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Lightless disconnected, clearing pair state");
+        }
+
+        ResetPairState();
+    }
+
+    private void ResetPairState()
+    {
+        _handlerRegistry.ResetAllHandlers();
+        _pairManager.ClearAll();
+        _pendingCharacterData.Clear();
+        _mediator.Publish(new ClearProfileUserDataMessage());
+        _mediator.Publish(new ClearProfileGroupDataMessage());
+        PublishPairDataChanged(groupChanged: true);
+    }
+
+    public void HandleGroupPairLeft(GroupPairDto dto)
+    {
+        var deregistration = _pairManager.RemoveGroupPair(dto);
+        if (deregistration.Success && deregistration.Value is { } registration && registration.CharacterIdent is not null)
+        {
+            _ = _handlerRegistry.DeregisterOfflinePair(registration, forceDisposal: true);
+        }
+        else if (!deregistration.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("RemoveGroupPair failed for {Uid}: {Error}", dto.User.UID, deregistration.Error);
+        }
+
+        if (deregistration.Success)
+        {
+            PublishPairDataChanged(groupChanged: true);
+        }
+    }
+
+    public void HandleGroupRemoved(GroupDto dto)
+    {
+        var removalResult = _pairManager.RemoveGroup(dto.Group.GID);
+        if (removalResult.Success)
+        {
+            foreach (var registration in removalResult.Value)
+            {
+                if (registration.CharacterIdent is not null)
+                {
+                    _ = _handlerRegistry.DeregisterOfflinePair(registration, forceDisposal: true);
+                }
+            }
+        }
+        else if (_logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to remove group {Group}: {Error}", dto.Group.GID, removalResult.Error);
+        }
+
+        if (removalResult.Success)
+        {
+            PublishPairDataChanged(groupChanged: true);
+        }
+    }
+
+    public void HandleGroupInfoUpdate(GroupInfoDto dto)
+    {
+        var result = _pairManager.UpdateGroupInfo(dto);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to update group info for {Group}: {Error}", dto.Group.GID, result.Error);
+            return;
+        }
+
+        PublishPairDataChanged(groupChanged: true);
+    }
+
+    public void HandleGroupPairPermissions(GroupPairUserPermissionDto dto)
+    {
+        var result = _pairManager.UpdateGroupPairPermissions(dto);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to update group pair permissions for {Group}: {Error}", dto.Group.GID, result.Error);
+            return;
+        }
+
+        PublishPairDataChanged(groupChanged: true);
+    }
+
+    public void HandleGroupPairStatus(GroupPairUserInfoDto dto, bool isSelf)
+    {
+        PairOperationResult result;
+        if (isSelf)
+        {
+            result = _pairManager.UpdateGroupStatus(dto);
+        }
+        else
+        {
+            result = _pairManager.UpdateGroupPairStatus(dto);
+        }
+
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to update group status for {Group}:{Uid}: {Error}", dto.GID, dto.UID, result.Error);
+            return;
+        }
+
+        PublishPairDataChanged(groupChanged: true);
+    }
+
+    public void HandleUserAddPair(UserPairDto dto, bool addToLastAddedUser = true)
+    {
+        var result = _pairManager.AddOrUpdateIndividual(dto, addToLastAddedUser);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to add/update pair {Uid}: {Error}", dto.User.UID, result.Error);
+            return;
+        }
+
+        PublishPairDataChanged();
+    }
+
+    public void HandleUserAddPair(UserFullPairDto dto)
+    {
+        var result = _pairManager.AddOrUpdateIndividual(dto);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to add/update full pair {Uid}: {Error}", dto.User.UID, result.Error);
+            return;
+        }
+
+        PublishPairDataChanged();
+    }
+
+    public void HandleUserRemovePair(UserDto dto)
+    {
+        var removal = _pairManager.RemoveIndividual(dto);
+        if (removal.Success && removal.Value is { } registration && registration.CharacterIdent is not null)
+        {
+            _ = _handlerRegistry.DeregisterOfflinePair(registration, forceDisposal: true);
+        }
+        else if (!removal.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("RemoveIndividual failed for {Uid}: {Error}", dto.User.UID, removal.Error);
+        }
+
+        if (removal.Success)
+        {
+            _pendingCharacterData.TryRemove(dto.User.UID, out _);
+            PublishPairDataChanged();
+        }
+    }
+
+    public void HandleUserStatus(UserIndividualPairStatusDto dto)
+    {
+        var result = _pairManager.SetIndividualStatus(dto);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to update individual pair status for {Uid}: {Error}", dto.User.UID, result.Error);
+            return;
+        }
+
+        PublishPairDataChanged();
+    }
+
+    public void HandleUserOnline(OnlineUserIdentDto dto, bool sendNotification)
+    {
+        var wasOnline = false;
+        PairConnection? previousConnection = null;
+        if (_pairManager.TryGetPair(dto.User.UID, out var existingConnection))
+        {
+            previousConnection = existingConnection;
+            wasOnline = existingConnection.IsOnline;
+        }
+
+        var registrationResult = _pairManager.MarkOnline(dto);
+        if (!registrationResult.Success)
+        {
+            _logger.LogDebug("MarkOnline failed for {Uid}: {Error}", dto.User.UID, registrationResult.Error);
+            return;
+        }
+
+        var registration = registrationResult.Value;
+        if (registration.CharacterIdent is null)
+        {
+            _logger.LogDebug("Online registration for {Uid} missing ident.", dto.User.UID);
+        }
+        else
+        {
+            var handlerResult = _handlerRegistry.RegisterOnlinePair(registration);
+            if (!handlerResult.Success && _logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("RegisterOnlinePair failed for {Uid}: {Error}", dto.User.UID, handlerResult.Error);
+            }
+        }
+
+        var connectionResult = _pairManager.GetPair(dto.User.UID);
+        var connection = connectionResult.Success ? connectionResult.Value : previousConnection;
+        if (connection is not null)
+        {
+            _mediator.Publish(new ClearProfileUserDataMessage(connection.User));
+        }
+        else
+        {
+            _mediator.Publish(new ClearProfileUserDataMessage(dto.User));
+        }
+
+        if (!wasOnline)
+        {
+            NotifyUserOnline(connection, sendNotification);
+        }
+
+        if (registration.CharacterIdent is not null &&
+            _pendingCharacterData.TryRemove(dto.User.UID, out var pendingData))
+        {
+            var pendingRegistration = new PairRegistration(new PairUniqueIdentifier(dto.User.UID), registration.CharacterIdent);
+            var pendingApply = _handlerRegistry.ApplyCharacterData(pendingRegistration, pendingData);
+            if (!pendingApply.Success && _logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("Applying pending character data for {Uid} failed: {Error}", dto.User.UID, pendingApply.Error);
+            }
+        }
+
+        PublishPairDataChanged();
+    }
+
+    public void HandleUserOffline(UserData user)
+    {
+        var registrationResult = _pairManager.MarkOffline(user);
+        if (registrationResult.Success)
+        {
+            _pendingCharacterData.TryRemove(user.UID, out _);
+            if (registrationResult.Value.CharacterIdent is not null)
+            {
+                _ = _handlerRegistry.DeregisterOfflinePair(registrationResult.Value);
+            }
+
+            _mediator.Publish(new ClearProfileUserDataMessage(user));
+            PublishPairDataChanged();
+        }
+        else if (_logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("MarkOffline failed for {Uid}: {Error}", user.UID, registrationResult.Error);
+        }
+    }
+
+    public void HandleUserPermissions(UserPermissionsDto dto)
+    {
+        var pairResult = _pairManager.GetPair(dto.User.UID);
+        if (!pairResult.Success)
+        {
+            if (_logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("Permission update received for unknown pair {Uid}", dto.User.UID);
+            }
+            return;
+        }
+
+        var connection = pairResult.Value;
+        var previous = connection.OtherToSelfPermissions;
+
+        var updateResult = _pairManager.UpdateOtherPermissions(dto);
+        if (!updateResult.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to update permissions for {Uid}: {Error}", dto.User.UID, updateResult.Error);
+            return;
+        }
+
+        PublishPairDataChanged();
+
+        if (previous.IsPaused() != dto.Permissions.IsPaused())
+        {
+            _mediator.Publish(new ClearProfileUserDataMessage(dto.User));
+
+            if (connection.Ident is not null)
+            {
+                var pauseResult = _handlerRegistry.SetPausedState(new PairUniqueIdentifier(dto.User.UID), connection.Ident, dto.Permissions.IsPaused());
+                if (!pauseResult.Success && _logger.IsEnabled(LogLevel.Debug))
+                {
+                    _logger.LogDebug("Failed to update pause state for {Uid}: {Error}", dto.User.UID, pauseResult.Error);
+                }
+            }
+        }
+
+        if (!connection.IsPaused && connection.Ident is not null)
+        {
+            ReapplyLastKnownData(dto.User.UID, connection.Ident);
+        }
+    }
+
+    public void HandleSelfPermissions(UserPermissionsDto dto)
+    {
+        var pairResult = _pairManager.GetPair(dto.User.UID);
+        if (!pairResult.Success)
+        {
+            if (_logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("Self permission update received for unknown pair {Uid}", dto.User.UID);
+            }
+            return;
+        }
+
+        var connection = pairResult.Value;
+        var previous = connection.SelfToOtherPermissions;
+
+        var updateResult = _pairManager.UpdateSelfPermissions(dto);
+        if (!updateResult.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to update self permissions for {Uid}: {Error}", dto.User.UID, updateResult.Error);
+            return;
+        }
+
+        PublishPairDataChanged();
+
+        if (previous.IsPaused() != dto.Permissions.IsPaused())
+        {
+            _mediator.Publish(new ClearProfileUserDataMessage(dto.User));
+
+            if (connection.Ident is not null)
+            {
+                var pauseResult = _handlerRegistry.SetPausedState(new PairUniqueIdentifier(dto.User.UID), connection.Ident, dto.Permissions.IsPaused());
+                if (!pauseResult.Success && _logger.IsEnabled(LogLevel.Debug))
+                {
+                    _logger.LogDebug("Failed to update pause state for {Uid}: {Error}", dto.User.UID, pauseResult.Error);
+                }
+            }
+        }
+
+        if (!connection.IsPaused && connection.Ident is not null)
+        {
+            ReapplyLastKnownData(dto.User.UID, connection.Ident);
+        }
+    }
+
+    public void HandleUploadStatus(UserDto dto)
+    {
+        var pairResult = _pairManager.GetPair(dto.User.UID);
+        if (!pairResult.Success)
+        {
+            if (_logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("Upload status received for unknown pair {Uid}", dto.User.UID);
+            }
+            return;
+        }
+
+        var connection = pairResult.Value;
+        if (connection.Ident is null)
+        {
+            return;
+        }
+
+        var setResult = _handlerRegistry.SetUploading(new PairUniqueIdentifier(dto.User.UID), connection.Ident, true);
+        if (!setResult.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to set uploading for {Uid}: {Error}", dto.User.UID, setResult.Error);
+        }
+    }
+
+    public void HandleCharacterData(OnlineUserCharaDataDto dto)
+    {
+        var pairResult = _pairManager.GetPair(dto.User.UID);
+        if (!pairResult.Success)
+        {
+            if (_logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("Character data received for unknown pair {Uid}, queued for later.", dto.User.UID);
+            }
+            _pendingCharacterData[dto.User.UID] = dto;
+            return;
+        }
+
+        var connection = pairResult.Value;
+        _mediator.Publish(new EventMessage(new Event(connection.User, nameof(PairCoordinator), EventSeverity.Informational, "Received Character Data")));
+        if (connection.Ident is null)
+        {
+            if (_logger.IsEnabled(LogLevel.Debug))
+            {
+                _logger.LogDebug("Character data received for {Uid} without ident, queued for later.", dto.User.UID);
+            }
+            _pendingCharacterData[dto.User.UID] = dto;
+            return;
+        }
+
+        _pendingCharacterData.TryRemove(dto.User.UID, out _);
+        var registration = new PairRegistration(new PairUniqueIdentifier(dto.User.UID), connection.Ident);
+        var applyResult = _handlerRegistry.ApplyCharacterData(registration, dto);
+        if (!applyResult.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("ApplyCharacterData queued for {Uid}: {Error}", dto.User.UID, applyResult.Error);
+        }
+    }
+
+    public void HandleProfile(UserDto dto)
+    {
+        _mediator.Publish(new ClearProfileUserDataMessage(dto.User));
+    }
+}

LightlessSync/PlayerData/Pairs/PairHandlerRegistry.cs

@@ -0,0 +1,493 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using LightlessSync.API.Data.Enum;
+using LightlessSync.API.Data.Extensions;
+using LightlessSync.API.Dto.CharaData;
+using LightlessSync.API.Dto.User;
+using Microsoft.Extensions.Logging;
+
+namespace LightlessSync.PlayerData.Pairs;
+
+public sealed class PairHandlerRegistry : IDisposable
+{
+    private readonly object _gate = new();
+    private readonly Dictionary<string, IPairHandlerAdapter> _identToHandler = new(StringComparer.Ordinal);
+    private readonly Dictionary<IPairHandlerAdapter, HashSet<PairUniqueIdentifier>> _handlerToPairs = new();
+    private readonly Dictionary<string, CancellationTokenSource> _waitingRequests = new(StringComparer.Ordinal);
+
+    private readonly IPairHandlerAdapterFactory _handlerFactory;
+    private readonly PairManager _pairManager;
+    private readonly PairStateCache _pairStateCache;
+    private readonly ILogger<PairHandlerRegistry> _logger;
+
+    private readonly TimeSpan _deletionGracePeriod = TimeSpan.FromMinutes(5);
+    private readonly TimeSpan _waitForHandlerGracePeriod = TimeSpan.FromMinutes(2);
+
+    public PairHandlerRegistry(
+        IPairHandlerAdapterFactory handlerFactory,
+        PairManager pairManager,
+        PairStateCache pairStateCache,
+        ILogger<PairHandlerRegistry> logger)
+    {
+        _handlerFactory = handlerFactory;
+        _pairManager = pairManager;
+        _pairStateCache = pairStateCache;
+        _logger = logger;
+    }
+
+    public int GetVisibleUsersCount()
+    {
+        lock (_gate)
+        {
+            return _handlerToPairs.Keys.Count(handler => handler.IsVisible);
+        }
+    }
+
+    public bool IsIdentVisible(string ident)
+    {
+        lock (_gate)
+        {
+            return _identToHandler.TryGetValue(ident, out var handler) && handler.IsVisible;
+        }
+    }
+
+    public PairOperationResult<PairUniqueIdentifier> RegisterOnlinePair(PairRegistration registration)
+    {
+        if (registration.CharacterIdent is null)
+        {
+            return PairOperationResult<PairUniqueIdentifier>.Fail($"Registration for {registration.PairIdent.UserId} missing ident.");
+        }
+
+        IPairHandlerAdapter handler;
+        lock (_gate)
+        {
+            handler = GetOrAddHandler(registration.CharacterIdent);
+            handler.ScheduledForDeletion = false;
+
+            if (!_handlerToPairs.TryGetValue(handler, out var set))
+            {
+                set = new HashSet<PairUniqueIdentifier>();
+                _handlerToPairs[handler] = set;
+            }
+
+            set.Add(registration.PairIdent);
+        }
+
+        ApplyPauseStateForHandler(handler);
+
+        if (handler.LastReceivedCharacterData is null)
+        {
+            var cachedData = _pairStateCache.TryLoad(registration.CharacterIdent);
+            if (cachedData is not null)
+            {
+                handler.LoadCachedCharacterData(cachedData);
+            }
+        }
+
+        if (handler.LastReceivedCharacterData is not null &&
+            (handler.LastAppliedApproximateVRAMBytes < 0 || handler.LastAppliedDataTris < 0))
+        {
+            handler.ApplyLastReceivedData(forced: true);
+        }
+
+        return PairOperationResult<PairUniqueIdentifier>.Ok(registration.PairIdent);
+    }
+
+    public PairOperationResult<PairUniqueIdentifier> DeregisterOfflinePair(PairRegistration registration, bool forceDisposal = false)
+    {
+        if (registration.CharacterIdent is null)
+        {
+            return PairOperationResult<PairUniqueIdentifier>.Fail($"Deregister for {registration.PairIdent.UserId} missing ident.");
+        }
+
+        IPairHandlerAdapter? handler = null;
+        bool shouldScheduleRemoval = false;
+        bool shouldDisposeImmediately = false;
+
+        lock (_gate)
+        {
+            if (!_identToHandler.TryGetValue(registration.CharacterIdent, out handler))
+            {
+                return PairOperationResult<PairUniqueIdentifier>.Fail($"Ident {registration.CharacterIdent} not registered.");
+            }
+
+            if (_handlerToPairs.TryGetValue(handler, out var set))
+            {
+                set.Remove(registration.PairIdent);
+                if (set.Count == 0)
+                {
+                    if (forceDisposal)
+                    {
+                        shouldDisposeImmediately = true;
+                    }
+                    else
+                    {
+                        shouldScheduleRemoval = true;
+                        handler.ScheduledForDeletion = true;
+                    }
+                }
+            }
+        }
+
+        if (shouldDisposeImmediately && handler is not null)
+        {
+            if (TryFinalizeHandlerRemoval(handler))
+            {
+                handler.Dispose();
+            }
+        }
+        else if (shouldScheduleRemoval && handler is not null)
+        {
+            _ = RemoveAfterGracePeriodAsync(handler);
+        }
+
+        return PairOperationResult<PairUniqueIdentifier>.Ok(registration.PairIdent);
+    }
+
+    public PairOperationResult ApplyCharacterData(PairRegistration registration, OnlineUserCharaDataDto dto)
+    {
+        if (registration.CharacterIdent is null)
+        {
+            return PairOperationResult.Fail($"Character data received without ident for {registration.PairIdent.UserId}.");
+        }
+
+        IPairHandlerAdapter? handler;
+        lock (_gate)
+        {
+            _identToHandler.TryGetValue(registration.CharacterIdent, out handler);
+        }
+
+        if (handler is null)
+        {
+            var registerResult = RegisterOnlinePair(registration);
+            if (!registerResult.Success)
+            {
+                return PairOperationResult.Fail(registerResult.Error);
+            }
+
+            lock (_gate)
+            {
+                _identToHandler.TryGetValue(registration.CharacterIdent, out handler);
+            }
+        }
+
+        if (handler is null)
+        {
+            return PairOperationResult.Fail($"Handler not ready for {registration.PairIdent.UserId}.");
+        }
+
+        handler.ApplyData(dto.CharaData);
+        return PairOperationResult.Ok();
+    }
+
+    public PairOperationResult ApplyLastReceivedData(PairUniqueIdentifier pairIdent, string ident, bool forced = false)
+    {
+        IPairHandlerAdapter? handler;
+        lock (_gate)
+        {
+            _identToHandler.TryGetValue(ident, out handler);
+        }
+
+        if (handler is null)
+        {
+            return PairOperationResult.Fail($"Cannot reapply data: handler for {pairIdent.UserId} not found.");
+        }
+
+        handler.ApplyLastReceivedData(forced);
+        return PairOperationResult.Ok();
+    }
+
+    public PairOperationResult SetUploading(PairUniqueIdentifier pairIdent, string ident, bool uploading)
+    {
+        IPairHandlerAdapter? handler;
+        lock (_gate)
+        {
+            _identToHandler.TryGetValue(ident, out handler);
+        }
+
+        if (handler is null)
+        {
+            return PairOperationResult.Fail($"Cannot set uploading for {pairIdent.UserId}: handler not found.");
+        }
+
+        handler.SetUploading(uploading);
+        return PairOperationResult.Ok();
+    }
+
+    public PairOperationResult SetPausedState(PairUniqueIdentifier pairIdent, string ident, bool paused)
+    {
+        IPairHandlerAdapter? handler;
+        lock (_gate)
+        {
+            _identToHandler.TryGetValue(ident, out handler);
+        }
+
+        if (handler is null)
+        {
+            return PairOperationResult.Fail($"Cannot update pause state for {pairIdent.UserId}: handler not found.");
+        }
+
+        _ = paused; // value reflected in pair manager already
+        // Recalculate pause state against all registered pairs to ensure consistency across contexts.
+        ApplyPauseStateForHandler(handler);
+        return PairOperationResult.Ok();
+    }
+
+    public PairOperationResult<IReadOnlyList<(PairUniqueIdentifier Ident, PairConnection Pair)>> GetPairConnections(string ident)
+    {
+        IPairHandlerAdapter? handler;
+        HashSet<PairUniqueIdentifier>? identifiers = null;
+
+        lock (_gate)
+        {
+            _identToHandler.TryGetValue(ident, out handler);
+            if (handler is not null)
+            {
+                _handlerToPairs.TryGetValue(handler, out identifiers);
+            }
+        }
+
+        if (handler is null || identifiers is null)
+        {
+            return PairOperationResult<IReadOnlyList<(PairUniqueIdentifier Ident, PairConnection Pair)>>.Fail($"No handler registered for {ident}.");
+        }
+
+        var list = new List<(PairUniqueIdentifier, PairConnection)>();
+        foreach (var pairIdent in identifiers)
+        {
+            var result = _pairManager.GetPair(pairIdent.UserId);
+            if (result.Success)
+            {
+                list.Add((pairIdent, result.Value));
+            }
+        }
+
+        return PairOperationResult<IReadOnlyList<(PairUniqueIdentifier Ident, PairConnection Pair)>>.Ok(list);
+    }
+
+    private void ApplyPauseStateForHandler(IPairHandlerAdapter handler)
+    {
+        var pairs = _pairManager.GetPairsByIdent(handler.Ident);
+        bool paused = pairs.Any(p => p.SelfToOtherPermissions.IsPaused() || p.OtherToSelfPermissions.IsPaused());
+        handler.SetPaused(paused);
+    }
+
+    internal bool TryGetHandler(string ident, out IPairHandlerAdapter? handler)
+    {
+        lock (_gate)
+        {
+            var success = _identToHandler.TryGetValue(ident, out var resolved);
+            handler = resolved;
+            return success;
+        }
+    }
+
+    internal IReadOnlyList<IPairHandlerAdapter> GetHandlerSnapshot()
+    {
+        lock (_gate)
+        {
+            return _identToHandler.Values.Distinct().ToList();
+        }
+    }
+
+    internal IReadOnlyCollection<PairUniqueIdentifier> GetRegisteredPairs(IPairHandlerAdapter handler)
+    {
+        lock (_gate)
+        {
+            if (_handlerToPairs.TryGetValue(handler, out var pairs))
+            {
+                return pairs.ToList();
+            }
+        }
+
+        return Array.Empty<PairUniqueIdentifier>();
+    }
+
+    internal void ReapplyAll(bool forced = false)
+    {
+        var handlers = GetHandlerSnapshot();
+        foreach (var handler in handlers)
+        {
+            try
+            {
+                handler.ApplyLastReceivedData(forced);
+            }
+            catch (Exception ex)
+            {
+                if (_logger.IsEnabled(LogLevel.Debug))
+                {
+                    _logger.LogDebug(ex, "Failed to reapply cached data for {Ident}", handler.Ident);
+                }
+            }
+        }
+    }
+
+    internal void ResetAllHandlers()
+    {
+        List<IPairHandlerAdapter> handlers;
+        lock (_gate)
+        {
+            handlers = _identToHandler.Values.Distinct().ToList();
+            _identToHandler.Clear();
+            _handlerToPairs.Clear();
+
+            foreach (var pending in _waitingRequests.Values)
+            {
+                pending.Cancel();
+                pending.Dispose();
+            }
+
+            _waitingRequests.Clear();
+        }
+
+        foreach (var handler in handlers)
+        {
+            try
+            {
+                handler.Dispose();
+            }
+            catch (Exception ex)
+            {
+                if (_logger.IsEnabled(LogLevel.Debug))
+                {
+                    _logger.LogDebug(ex, "Failed to dispose handler for {Ident}", handler.Ident);
+                }
+            }
+        }
+    }
+
+    public void Dispose()
+    {
+        List<IPairHandlerAdapter> handlers;
+        lock (_gate)
+        {
+            handlers = _identToHandler.Values.Distinct().ToList();
+            _identToHandler.Clear();
+            _handlerToPairs.Clear();
+            foreach (var kv in _waitingRequests.Values)
+            {
+                kv.Cancel();
+            }
+            _waitingRequests.Clear();
+        }
+
+        foreach (var handler in handlers)
+        {
+            handler.Dispose();
+        }
+    }
+
+    private IPairHandlerAdapter GetOrAddHandler(string ident)
+    {
+        if (_identToHandler.TryGetValue(ident, out var handler))
+        {
+            return handler;
+        }
+
+        handler = _handlerFactory.Create(ident);
+        _identToHandler[ident] = handler;
+        _handlerToPairs[handler] = new HashSet<PairUniqueIdentifier>();
+        return handler;
+    }
+
+    private void EnsureInitialized(IPairHandlerAdapter handler)
+    {
+        if (handler.Initialized)
+        {
+            return;
+        }
+
+        try
+        {
+            handler.Initialize();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to initialize handler for {Ident}", handler.Ident);
+        }
+    }
+
+    private async Task RemoveAfterGracePeriodAsync(IPairHandlerAdapter handler)
+    {
+        try
+        {
+            await Task.Delay(_deletionGracePeriod).ConfigureAwait(false);
+        }
+        catch (TaskCanceledException)
+        {
+            return;
+        }
+
+        if (TryFinalizeHandlerRemoval(handler))
+        {
+            handler.Dispose();
+        }
+    }
+
+    private bool TryFinalizeHandlerRemoval(IPairHandlerAdapter handler)
+    {
+        lock (_gate)
+        {
+            if (!_handlerToPairs.TryGetValue(handler, out var set) || set.Count > 0)
+            {
+                handler.ScheduledForDeletion = false;
+                return false;
+            }
+
+            _handlerToPairs.Remove(handler);
+            _identToHandler.Remove(handler.Ident);
+
+            if (_waitingRequests.TryGetValue(handler.Ident, out var cts))
+            {
+                cts.Cancel();
+                cts.Dispose();
+                _waitingRequests.Remove(handler.Ident);
+            }
+
+            return true;
+        }
+    }
+
+    private async Task WaitThenApplyDataAsync(PairRegistration registration, OnlineUserCharaDataDto dto, CancellationTokenSource cts)
+    {
+        var token = cts.Token;
+        try
+        {
+            while (!token.IsCancellationRequested)
+            {
+                IPairHandlerAdapter? handler;
+                lock (_gate)
+                {
+                    _identToHandler.TryGetValue(registration.CharacterIdent!, out handler);
+                }
+
+                if (handler is not null && handler.Initialized)
+                {
+                    handler.ApplyData(dto.CharaData);
+                    break;
+                }
+
+                await Task.Delay(TimeSpan.FromMilliseconds(500), token).ConfigureAwait(false);
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // expected
+        }
+        finally
+        {
+            lock (_gate)
+            {
+                if (_waitingRequests.TryGetValue(registration.CharacterIdent!, out var existing) && existing == cts)
+                {
+                    _waitingRequests.Remove(registration.CharacterIdent!);
+                }
+            }
+
+            cts.Dispose();
+        }
+    }
+}

LightlessSync/PlayerData/Pairs/PairLedger.cs

@@ -0,0 +1,293 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using LightlessSync.API.Data;
+using LightlessSync.API.Dto.Group;
+using LightlessSync.Services.Events;
+using LightlessSync.Services.Mediator;
+using LightlessSync.UI.Models;
+using Microsoft.Extensions.Logging;
+
+namespace LightlessSync.PlayerData.Pairs;
+
+public sealed class PairLedger : DisposableMediatorSubscriberBase
+{
+    private readonly PairManager _pairManager;
+    private readonly PairHandlerRegistry _registry;
+    private readonly ILogger<PairLedger> _logger;
+    private readonly object _metricsGate = new();
+    private CancellationTokenSource? _ensureMetricsCts;
+
+    public PairLedger(
+        ILogger<PairLedger> logger,
+        LightlessMediator mediator,
+        PairManager pairManager,
+        PairHandlerRegistry registry) : base(logger, mediator)
+    {
+        _pairManager = pairManager;
+        _registry = registry;
+        _logger = logger;
+
+        Mediator.Subscribe<CutsceneEndMessage>(this, _ => ReapplyAll(forced: true));
+        Mediator.Subscribe<GposeEndMessage>(this, _ => ReapplyAll());
+        Mediator.Subscribe<PenumbraInitializedMessage>(this, _ => ReapplyAll(forced: true));
+        Mediator.Subscribe<FileCacheInitializedMessage>(this, _ => ReapplyAll(forced: true));
+        Mediator.Subscribe<DisconnectedMessage>(this, _ => Reset());
+        Mediator.Subscribe<ConnectedMessage>(this, _ => ScheduleEnsureMetrics(TimeSpan.FromSeconds(2)));
+        Mediator.Subscribe<HubReconnectedMessage>(this, _ => ScheduleEnsureMetrics(TimeSpan.FromSeconds(2)));
+        Mediator.Subscribe<DalamudLoginMessage>(this, _ => ScheduleEnsureMetrics(TimeSpan.FromSeconds(2)));
+        Mediator.Subscribe<VisibilityChange>(this, _ => EnsureMetricsForVisiblePairs());
+    }
+
+    public bool IsPairVisible(PairUniqueIdentifier pairIdent)
+    {
+        var connectionResult = _pairManager.GetPair(pairIdent.UserId);
+        if (!connectionResult.Success)
+        {
+            return false;
+        }
+
+        var connection = connectionResult.Value;
+        if (connection.Ident is null)
+        {
+            return false;
+        }
+
+        return _registry.IsIdentVisible(connection.Ident);
+    }
+
+    public IPairHandlerAdapter? GetHandler(PairUniqueIdentifier pairIdent)
+    {
+        var connectionResult = _pairManager.GetPair(pairIdent.UserId);
+        if (!connectionResult.Success)
+        {
+            return null;
+        }
+
+        var connection = connectionResult.Value;
+        if (connection.Ident is null)
+        {
+            return null;
+        }
+
+        return _registry.TryGetHandler(connection.Ident, out var handler) ? handler : null;
+    }
+
+    public IReadOnlyList<PairConnection> GetVisiblePairs()
+    {
+        return _pairManager.GetAllPairs()
+            .Select(kv => kv.Value)
+            .Where(connection => connection.Ident is not null && _registry.IsIdentVisible(connection.Ident))
+            .ToList();
+    }
+
+    public IReadOnlyList<GroupFullInfoDto> GetAllGroupInfos()
+    {
+        return _pairManager.GetAllGroups()
+            .Select(kv => kv.Value.GroupFullInfo)
+            .ToList();
+    }
+
+    public IReadOnlyDictionary<string, Syncshell> GetAllSyncshells()
+    {
+        return _pairManager.GetAllGroups();
+    }
+
+    public void ReapplyAll(bool forced = false)
+    {
+        if (_logger.IsEnabled(LogLevel.Trace))
+        {
+            _logger.LogTrace("Reapplying cached data for all handlers (forced: {Forced})", forced);
+        }
+
+        _registry.ReapplyAll(forced);
+    }
+
+    public void ReapplyPair(PairUniqueIdentifier pairIdent, bool forced = false)
+    {
+        var connectionResult = _pairManager.GetPair(pairIdent.UserId);
+        if (!connectionResult.Success)
+        {
+            return;
+        }
+
+        var connection = connectionResult.Value;
+        if (connection.Ident is null)
+        {
+            return;
+        }
+
+        var result = _registry.ApplyLastReceivedData(pairIdent, connection.Ident, forced);
+        if (!result.Success && _logger.IsEnabled(LogLevel.Debug))
+        {
+            _logger.LogDebug("Failed to reapply data for {UserId}: {Error}", pairIdent.UserId, result.Error);
+        }
+    }
+
+    private void Reset()
+    {
+        if (_logger.IsEnabled(LogLevel.Trace))
+        {
+            _logger.LogTrace("Resetting pair handlers after disconnect.");
+        }
+
+        CancelScheduledMetrics();
+    }
+
+    public IReadOnlyList<PairDisplayEntry> GetAllEntries()
+    {
+        var groups = _pairManager.GetAllGroups();
+        var list = new List<PairDisplayEntry>();
+        foreach (var (userId, connection) in _pairManager.GetAllPairs())
+        {
+            var ident = new PairUniqueIdentifier(userId);
+            IPairHandlerAdapter? handler = null;
+            if (connection.Ident is not null)
+            {
+                _registry.TryGetHandler(connection.Ident, out handler);
+            }
+
+            var groupInfos = connection.Groups.Keys
+                .Select(gid =>
+                {
+                    if (groups.TryGetValue(gid, out var shell))
+                    {
+                        return shell.GroupFullInfo;
+                    }
+                    return null;
+                })
+                .Where(dto => dto is not null)
+                .Cast<GroupFullInfoDto>()
+                .ToList();
+
+            list.Add(new PairDisplayEntry(ident, connection, groupInfos, handler));
+        }
+
+        return list;
+    }
+
+    public bool TryGetEntry(PairUniqueIdentifier ident, out PairDisplayEntry? entry)
+    {
+        entry = null;
+        var connectionResult = _pairManager.GetPair(ident.UserId);
+        if (!connectionResult.Success)
+        {
+            return false;
+        }
+
+        var connection = connectionResult.Value;
+        var groups = connection.Groups.Keys
+            .Select(gid =>
+            {
+                var groupResult = _pairManager.GetGroup(gid);
+                return groupResult.Success ? groupResult.Value.GroupFullInfo : null;
+            })
+            .Where(dto => dto is not null)
+            .Cast<GroupFullInfoDto>()
+            .ToList();
+
+        IPairHandlerAdapter? handler = null;
+        if (connection.Ident is not null)
+        {
+            _registry.TryGetHandler(connection.Ident, out handler);
+        }
+
+        entry = new PairDisplayEntry(ident, connection, groups, handler);
+        return true;
+    }
+
+    private void ScheduleEnsureMetrics(TimeSpan? delay = null)
+    {
+        lock (_metricsGate)
+        {
+            _ensureMetricsCts?.Cancel();
+            var cts = new CancellationTokenSource();
+            _ensureMetricsCts = cts;
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    if (delay is { } d && d > TimeSpan.Zero)
+                    {
+                        await Task.Delay(d, cts.Token).ConfigureAwait(false);
+                    }
+
+                    EnsureMetricsForVisiblePairs();
+                }
+                catch (OperationCanceledException)
+                {
+                    // ignored
+                }
+                finally
+                {
+                    lock (_metricsGate)
+                    {
+                        if (_ensureMetricsCts == cts)
+                        {
+                            _ensureMetricsCts = null;
+                        }
+                    }
+
+                    cts.Dispose();
+                }
+            });
+        }
+    }
+
+    private void CancelScheduledMetrics()
+    {
+        lock (_metricsGate)
+        {
+            _ensureMetricsCts?.Cancel();
+            _ensureMetricsCts = null;
+        }
+    }
+
+    private void EnsureMetricsForVisiblePairs()
+    {
+        var handlers = _registry.GetHandlerSnapshot();
+        foreach (var handler in handlers)
+        {
+            if (!handler.IsVisible)
+            {
+                continue;
+            }
+
+            if (handler.LastReceivedCharacterData is null)
+            {
+                continue;
+            }
+
+            if (handler.LastAppliedApproximateVRAMBytes >= 0
+                && handler.LastAppliedDataTris >= 0
+                && handler.LastAppliedApproximateEffectiveVRAMBytes >= 0)
+            {
+                continue;
+            }
+
+            try
+            {
+                handler.ApplyLastReceivedData(forced: true);
+            }
+            catch (Exception ex)
+            {
+                if (_logger.IsEnabled(LogLevel.Debug))
+                {
+                    _logger.LogDebug(ex, "Failed to ensure performance metrics for {Ident}", handler.Ident);
+                }
+            }
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        if (disposing)
+        {
+            CancelScheduledMetrics();
+        }
+
+        base.Dispose(disposing);
+    }
+}

LightlessSync/PlayerData/Pairs/PairState.cs

@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using LightlessSync.API.Data;
+using LightlessSync.API.Data.Enum;
+using LightlessSync.API.Data.Extensions;
+using LightlessSync.API.Dto.Group;
+
+namespace LightlessSync.PlayerData.Pairs;
+
+public readonly struct PairOperationResult
+{
+    private PairOperationResult(bool success, string? error)
+    {
+        Success = success;
+        Error = error;
+    }
+
+    public bool Success { get; }
+    public string? Error { get; }
+
+    public static PairOperationResult Ok() => new(true, null);
+
+    public static PairOperationResult Fail(string error) => new(false, error);
+}
+
+public readonly struct PairOperationResult<T>
+{
+    private PairOperationResult(bool success, T value, string? error)
+    {
+        Success = success;
+        Value = value;
+        Error = error;
+    }
+
+    public bool Success { get; }
+    public T Value { get; }
+    public string? Error { get; }
+
+    public static PairOperationResult<T> Ok(T value) => new(true, value, null);
+
+    public static PairOperationResult<T> Fail(string error) => new(false, default!, error);
+}
+
+public sealed record PairRegistration(PairUniqueIdentifier PairIdent, string? CharacterIdent);
+
+public sealed class GroupPairRelationship
+{
+    public GroupPairRelationship(string groupId, GroupPairUserInfo? info)
+    {
+        GroupId = groupId;
+        UserInfo = info;
+    }
+
+    public string GroupId { get; }
+    public GroupPairUserInfo? UserInfo { get; private set; }
+
+    public void SetUserInfo(GroupPairUserInfo? info)
+    {
+        UserInfo = info;
+    }
+}
+
+public sealed class PairConnection
+{
+    public PairConnection(UserData user)
+    {
+        User = user;
+        Groups = new Dictionary<string, GroupPairRelationship>(StringComparer.Ordinal);
+    }
+
+    public UserData User { get; }
+    public bool IsOnline { get; private set; }
+    public string? Ident { get; private set; }
+    public UserPermissions SelfToOtherPermissions { get; private set; } = UserPermissions.NoneSet;
+    public UserPermissions OtherToSelfPermissions { get; private set; } = UserPermissions.NoneSet;
+    public IndividualPairStatus? IndividualPairStatus { get; private set; }
+    public Dictionary<string, GroupPairRelationship> Groups { get; }
+
+    public bool IsPaused => SelfToOtherPermissions.IsPaused();
+    public bool IsDirectlyPaired => IndividualPairStatus is not null && IndividualPairStatus != API.Data.Enum.IndividualPairStatus.None;
+    public bool IsOneSided => IndividualPairStatus == API.Data.Enum.IndividualPairStatus.OneSided;
+    public bool HasAnyConnection => IsDirectlyPaired || Groups.Count > 0;
+
+    public void SetOnline(string? ident)
+    {
+        IsOnline = true;
+        Ident = ident;
+    }
+
+    public void SetOffline()
+    {
+        IsOnline = false;
+    }
+
+    public void UpdatePermissions(UserPermissions own, UserPermissions other)
+    {
+        SelfToOtherPermissions = own;
+        OtherToSelfPermissions = other;
+    }
+
+    public void UpdateStatus(IndividualPairStatus? status)
+    {
+        IndividualPairStatus = status;
+    }
+
+    public void EnsureGroupRelationship(string groupId, GroupPairUserInfo? info)
+    {
+        if (Groups.TryGetValue(groupId, out var relationship))
+        {
+            relationship.SetUserInfo(info);
+        }
+        else
+        {
+            Groups[groupId] = new GroupPairRelationship(groupId, info);
+        }
+    }
+
+    public void RemoveGroupRelationship(string groupId)
+    {
+        Groups.Remove(groupId);
+    }
+}
+
+public sealed class Syncshell
+{
+    public Syncshell(GroupFullInfoDto dto)
+    {
+        GroupFullInfo = dto;
+        Users = new Dictionary<string, PairConnection>(StringComparer.Ordinal);
+    }
+
+    public GroupFullInfoDto GroupFullInfo { get; private set; }
+    public Dictionary<string, PairConnection> Users { get; }
+
+    public void Update(GroupFullInfoDto dto)
+    {
+        GroupFullInfo = dto;
+    }
+}
+
+public sealed class PairState
+{
+    public CharacterData? CharacterData { get; set; }
+    public Guid? TemporaryCollectionId { get; set; }
+
+    public bool IsEmpty => CharacterData is null && (TemporaryCollectionId is null || TemporaryCollectionId == Guid.Empty);
+}
+
+public readonly record struct PairUniqueIdentifier(string UserId);

LightlessSync/PlayerData/Pairs/PairStateCache.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using LightlessSync.API.Data;
+using LightlessSync.Utils;
+
+namespace LightlessSync.PlayerData.Pairs;
+
+public sealed class PairStateCache
+{
+    private readonly ConcurrentDictionary<string, PairState> _cache = new(StringComparer.Ordinal);
+
+    public void Store(string ident, CharacterData data)
+    {
+        if (string.IsNullOrEmpty(ident) || data is null)
+        {
+            return;
+        }
+
+        var state = _cache.GetOrAdd(ident, _ => new PairState());
+        state.CharacterData = data.DeepClone();
+    }
+
+    public CharacterData? TryLoad(string ident)
+    {
+        if (string.IsNullOrEmpty(ident))
+        {
+            return null;
+        }
+
+        if (_cache.TryGetValue(ident, out var state) && state.CharacterData is not null)
+        {
+            return state.CharacterData.DeepClone();
+        }
+
+        return null;
+    }
+
+    public Guid? TryGetTemporaryCollection(string ident)
+    {
+        if (string.IsNullOrEmpty(ident))
+        {
+            return null;
+        }
+
+        if (_cache.TryGetValue(ident, out var state))
+        {
+            return state.TemporaryCollectionId;
+        }
+
+        return null;
+    }
+
+    public Guid? StoreTemporaryCollection(string ident, Guid collection)
+    {
+        if (string.IsNullOrEmpty(ident) || collection == Guid.Empty)
+        {
+            return null;
+        }
+
+        var state = _cache.GetOrAdd(ident, _ => new PairState());
+        state.TemporaryCollectionId = collection;
+        return collection;
+    }
+
+    public Guid? ClearTemporaryCollection(string ident)
+    {
+        if (string.IsNullOrEmpty(ident))
+        {
+            return null;
+        }
+
+        if (_cache.TryGetValue(ident, out var state))
+        {
+            var existing = state.TemporaryCollectionId;
+            state.TemporaryCollectionId = null;
+            TryRemoveIfEmpty(ident, state);
+            return existing;
+        }
+
+        return null;
+    }
+
+    public IReadOnlyList<Guid> ClearAllTemporaryCollections()
+    {
+        var removed = new List<Guid>();
+        foreach (var (ident, state) in _cache)
+        {
+            if (state.TemporaryCollectionId is { } guid && guid != Guid.Empty)
+            {
+                removed.Add(guid);
+                state.TemporaryCollectionId = null;
+            }
+
+            TryRemoveIfEmpty(ident, state);
+        }
+
+        return removed;
+    }
+
+    public void Clear(string ident)
+    {
+        if (string.IsNullOrEmpty(ident))
+        {
+            return;
+        }
+
+        _cache.TryRemove(ident, out _);
+    }
+
+    private void TryRemoveIfEmpty(string ident, PairState state)
+    {
+        if (state.IsEmpty)
+        {
+            _cache.TryRemove(ident, out _);
+        }
+    }
+}

LightlessSync/PlayerData/Pairs/VisibleUserDataDistributor.cs

@@ -1,10 +1,17 @@
+using System;
 using LightlessSync.API.Data;
-using LightlessSync.Services;
-using LightlessSync.Services.Mediator;
+using LightlessSync.API.Data.Comparer;
+using LightlessSync.PlayerData.Pairs;
 using LightlessSync.Utils;
+using LightlessSync.Services.Mediator;
+using LightlessSync.Services;
 using LightlessSync.WebAPI;
 using LightlessSync.WebAPI.Files;
 using Microsoft.Extensions.Logging;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
 
 namespace LightlessSync.PlayerData.Pairs;
 
@@ -13,22 +20,24 @@ public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
     private readonly ApiController _apiController;
     private readonly DalamudUtilService _dalamudUtil;
     private readonly FileUploadManager _fileTransferManager;
-    private readonly PairManager _pairManager;
+    private readonly PairLedger _pairLedger;
     private CharacterData? _lastCreatedData;
     private CharacterData? _uploadingCharacterData = null;
     private readonly List<UserData> _previouslyVisiblePlayers = [];
     private Task<CharacterData>? _fileUploadTask = null;
-    private readonly HashSet<UserData> _usersToPushDataTo = [];
+    private readonly HashSet<UserData> _usersToPushDataTo = new(UserDataComparer.Instance);
     private readonly SemaphoreSlim _pushDataSemaphore = new(1, 1);
     private readonly CancellationTokenSource _runtimeCts = new();
+    private readonly Dictionary<string, string> _lastPushedHashes = new(StringComparer.Ordinal);
+    private readonly object _pushSync = new();
 
 
     public VisibleUserDataDistributor(ILogger<VisibleUserDataDistributor> logger, ApiController apiController, DalamudUtilService dalamudUtil,
-        PairManager pairManager, LightlessMediator mediator, FileUploadManager fileTransferManager) : base(logger, mediator)
+        PairLedger pairLedger, LightlessMediator mediator, FileUploadManager fileTransferManager) : base(logger, mediator)
     {
         _apiController = apiController;
         _dalamudUtil = dalamudUtil;
-        _pairManager = pairManager;
+        _pairLedger = pairLedger;
         _fileTransferManager = fileTransferManager;
         Mediator.Subscribe<DelayedFrameworkUpdateMessage>(this, (_) => FrameworkOnUpdate());
         Mediator.Subscribe<CharacterDataCreatedMessage>(this, (msg) =>
@@ -47,7 +56,7 @@ public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
         });
 
         Mediator.Subscribe<ConnectedMessage>(this, (_) => PushToAllVisibleUsers());
-        Mediator.Subscribe<DisconnectedMessage>(this, (_) => _previouslyVisiblePlayers.Clear());
+        Mediator.Subscribe<DisconnectedMessage>(this, (_) => HandleDisconnected());
     }
 
     protected override void Dispose(bool disposing)
@@ -63,15 +72,18 @@ public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
 
     private void PushToAllVisibleUsers(bool forced = false)
     {
-        foreach (var user in _pairManager.GetVisibleUsers())
+        lock (_pushSync)
         {
-            _usersToPushDataTo.Add(user);
-        }
+            foreach (var user in GetVisibleUsers())
+            {
+                _usersToPushDataTo.Add(user);
+            }
 
-        if (_usersToPushDataTo.Count > 0)
-        {
-            Logger.LogDebug("Pushing data {hash} for {count} visible players", _lastCreatedData?.DataHash.Value ?? "UNKNOWN", _usersToPushDataTo.Count);
-            PushCharacterData(forced);
+            if (_usersToPushDataTo.Count > 0)
+            {
+                Logger.LogDebug("Pushing data {hash} for {count} visible players", _lastCreatedData?.DataHash.Value ?? "UNKNOWN", _usersToPushDataTo.Count);
+                PushCharacterData_internalLocked(forced);
+            }
         }
     }
 
@@ -79,8 +91,10 @@ public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
     {
         if (!_dalamudUtil.GetIsPlayerPresent() || !_apiController.IsConnected) return;
 
-        var allVisibleUsers = _pairManager.GetVisibleUsers();
-        var newVisibleUsers = allVisibleUsers.Except(_previouslyVisiblePlayers).ToList();
+        var allVisibleUsers = GetVisibleUsers();
+        var newVisibleUsers = allVisibleUsers
+            .Except(_previouslyVisiblePlayers, UserDataComparer.Instance)
+            .ToList();
         _previouslyVisiblePlayers.Clear();
         _previouslyVisiblePlayers.AddRange(allVisibleUsers);
         if (newVisibleUsers.Count == 0) return;
@@ -88,56 +102,144 @@ public class VisibleUserDataDistributor : DisposableMediatorSubscriberBase
         Logger.LogDebug("Scheduling character data push of {data} to {users}",
             _lastCreatedData?.DataHash.Value ?? string.Empty,
             string.Join(", ", newVisibleUsers.Select(k => k.AliasOrUID)));
-        foreach (var user in newVisibleUsers)
+        lock (_pushSync)
         {
-            _usersToPushDataTo.Add(user);
+            foreach (var user in newVisibleUsers)
+            {
+                _usersToPushDataTo.Add(user);
+            }
+            PushCharacterData_internalLocked();
         }
-        PushCharacterData();
     }
 
     private void PushCharacterData(bool forced = false)
+    {
+        lock (_pushSync)
+        {
+            PushCharacterData_internalLocked(forced);
+        }
+    }
+
+    private void PushCharacterData_internalLocked(bool forced = false)
     {
         if (_lastCreatedData == null || _usersToPushDataTo.Count == 0) return;
+        if (!_apiController.IsConnected || !_fileTransferManager.IsReady)
+        {
+            Logger.LogTrace("Skipping character push. Connected: {connected}, UploadManagerReady: {ready}",
+                _apiController.IsConnected, _fileTransferManager.IsReady);
+            return;
+        }
 
         _ = Task.Run(async () =>
         {
             try
             {
-            forced |= _uploadingCharacterData?.DataHash != _lastCreatedData.DataHash;
+                Task<CharacterData>? uploadTask;
+                bool forcedPush;
+                lock (_pushSync)
+                {
+                    if (_lastCreatedData == null || _usersToPushDataTo.Count == 0) return;
+                    forcedPush = forced | (_uploadingCharacterData?.DataHash != _lastCreatedData.DataHash);
 
-            if (_fileUploadTask == null || (_fileUploadTask?.IsCompleted ?? false) || forced)
-            {
-                _uploadingCharacterData = _lastCreatedData.DeepClone();
-                Logger.LogDebug("Starting UploadTask for {hash}, Reason: TaskIsNull: {task}, TaskIsCompleted: {taskCpl}, Forced: {frc}",
-                    _lastCreatedData.DataHash, _fileUploadTask == null, _fileUploadTask?.IsCompleted ?? false, forced);
-                _fileUploadTask = _fileTransferManager.UploadFiles(_uploadingCharacterData, [.. _usersToPushDataTo]);
-            }
+                    if (_fileUploadTask == null || (_fileUploadTask?.IsCompleted ?? false) || forcedPush)
+                    {
+                        _uploadingCharacterData = _lastCreatedData.DeepClone();
+                        Logger.LogDebug("Starting UploadTask for {hash}, Reason: TaskIsNull: {task}, TaskIsCompleted: {taskCpl}, Forced: {frc}",
+                            _lastCreatedData.DataHash, _fileUploadTask == null, _fileUploadTask?.IsCompleted ?? false, forcedPush);
+                        _fileUploadTask = _fileTransferManager.UploadFiles(_uploadingCharacterData, [.. _usersToPushDataTo]);
+                    }
 
-            if (_fileUploadTask != null)
-            {
-                var dataToSend = await _fileUploadTask.ConfigureAwait(false);
+                    uploadTask = _fileUploadTask;
+                }
+
+                var dataToSend = await uploadTask.ConfigureAwait(false);
+                var dataHash = dataToSend.DataHash.Value;
                 await _pushDataSemaphore.WaitAsync(_runtimeCts.Token).ConfigureAwait(false);
                 try
                 {
-                    if (_usersToPushDataTo.Count == 0) return;
-                    Logger.LogDebug("Pushing {data} to {users}", dataToSend.DataHash, string.Join(", ", _usersToPushDataTo.Select(k => k.AliasOrUID)));
-                    await _apiController.PushCharacterData(dataToSend, [.. _usersToPushDataTo]).ConfigureAwait(false);
-                    _usersToPushDataTo.Clear();
+                    List<UserData> recipients;
+                    bool shouldSkip = false;
+                    lock (_pushSync)
+                    {
+                        if (_usersToPushDataTo.Count == 0) return;
+                        recipients = forcedPush
+                            ? _usersToPushDataTo.ToList()
+                            : _usersToPushDataTo
+                                .Where(user => !_lastPushedHashes.TryGetValue(user.UID, out var sentHash) || !string.Equals(sentHash, dataHash, StringComparison.Ordinal))
+                                .ToList();
+
+                        if (recipients.Count == 0 && !forcedPush)
+                        {
+                            Logger.LogTrace("All recipients already have character data hash {hash}, skipping push.", dataHash);
+                            _usersToPushDataTo.Clear();
+                            shouldSkip = true;
+                        }
+                    }
+
+                    if (shouldSkip)
+                        return;
+
+                    Logger.LogDebug("Pushing {data} to {users}", dataHash, string.Join(", ", recipients.Select(k => k.AliasOrUID)));
+                    await _apiController.PushCharacterData(dataToSend, recipients).ConfigureAwait(false);
+
+                    lock (_pushSync)
+                    {
+                        foreach (var user in recipients)
+                        {
+                            _lastPushedHashes[user.UID] = dataHash;
+                            _usersToPushDataTo.Remove(user);
+                        }
+
+                        if (!forcedPush && _usersToPushDataTo.Count > 0)
+                        {
+                            foreach (var satisfied in _usersToPushDataTo
+                                         .Where(user => _lastPushedHashes.TryGetValue(user.UID, out var sentHash) && string.Equals(sentHash, dataHash, StringComparison.Ordinal))
+                                         .ToList())
+                            {
+                                _usersToPushDataTo.Remove(satisfied);
+                            }
+                        }
+
+                        if (forcedPush)
+                        {
+                            _usersToPushDataTo.Clear();
+                        }
+                    }
                 }
                 finally
                 {
                     _pushDataSemaphore.Release();
                 }
             }
-        }
-        catch (OperationCanceledException) when (_runtimeCts.IsCancellationRequested)
-        {
-            Logger.LogDebug("PushCharacterData cancelled");
-        }
-        catch (Exception ex)
-        {
-            Logger.LogError(ex, "Failed to push character data");
-        }
+            catch (OperationCanceledException) when (_runtimeCts.IsCancellationRequested)
+            {
+                Logger.LogDebug("PushCharacterData cancelled");
+            }
+            catch (Exception ex)
+            {
+                Logger.LogError(ex, "Failed to push character data");
+            }
         });
     }
-}
+
+    private void HandleDisconnected()
+    {
+        _fileTransferManager.CancelUpload();
+        _previouslyVisiblePlayers.Clear();
+
+        lock (_pushSync)
+        {
+            _usersToPushDataTo.Clear();
+            _lastPushedHashes.Clear();
+            _uploadingCharacterData = null;
+            _fileUploadTask = null;
+        }
+    }
+
+    private List<UserData> GetVisibleUsers()
+    {
+        return _pairLedger.GetVisiblePairs()
+            .Select(connection => connection.User)
+            .ToList();
+    }
+}