Initial

MareSynchronos/.editorconfig

@@ -0,0 +1,120 @@
+
+[*.{cs,vb}]
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers =
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers =
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers =
+
+# Naming styles
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix =
+dotnet_naming_style.begins_with_i.word_separator =
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix =
+dotnet_naming_style.pascal_case.required_suffix =
+dotnet_naming_style.pascal_case.word_separator =
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.pascal_case.required_prefix =
+dotnet_naming_style.pascal_case.required_suffix =
+dotnet_naming_style.pascal_case.word_separator =
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+tab_width = 4
+indent_size = 4
+end_of_line = crlf
+dotnet_style_coalesce_expression = true:suggestion
+dotnet_style_null_propagation = true:suggestion
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion
+dotnet_style_prefer_auto_properties = true:silent
+dotnet_style_object_initializer = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_prefer_simplified_boolean_expressions = true:suggestion
+dotnet_style_prefer_conditional_expression_over_assignment = true:silent
+dotnet_style_prefer_conditional_expression_over_return = true:silent
+dotnet_style_explicit_tuple_names = true:suggestion
+dotnet_style_prefer_inferred_tuple_names = true:suggestion
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:suggestion
+dotnet_style_prefer_compound_assignment = true:suggestion
+dotnet_style_prefer_simplified_interpolation = true:suggestion
+dotnet_style_namespace_match_folder = true:suggestion
+
+[*.cs]
+csharp_indent_labels = one_less_than_current
+csharp_using_directive_placement = outside_namespace:silent
+csharp_prefer_simple_using_statement = true:suggestion
+csharp_prefer_braces = true:silent
+csharp_style_namespace_declarations = block_scoped:silent
+csharp_style_prefer_method_group_conversion = true:silent
+csharp_style_prefer_top_level_statements = true:silent
+csharp_style_expression_bodied_methods = false:silent
+csharp_style_expression_bodied_constructors = false:silent
+csharp_style_expression_bodied_operators = false:silent
+csharp_style_expression_bodied_properties = true:silent
+csharp_style_expression_bodied_indexers = true:silent
+csharp_style_expression_bodied_accessors = true:silent
+csharp_style_expression_bodied_lambdas = true:silent
+csharp_style_expression_bodied_local_functions = false:silent
+dotnet_diagnostic.MA0076.severity = silent
+dotnet_diagnostic.MA0051.severity = silent
+csharp_style_throw_expression = true:suggestion
+csharp_style_prefer_null_check_over_type_check = true:suggestion
+csharp_prefer_simple_default_expression = true:suggestion
+csharp_style_prefer_local_over_anonymous_function = true:suggestion
+csharp_style_prefer_index_operator = true:suggestion
+csharp_style_prefer_range_operator = true:suggestion
+csharp_style_implicit_object_creation_when_type_is_apparent = true:suggestion
+csharp_style_prefer_tuple_swap = true:suggestion
+csharp_style_prefer_utf8_string_literals = true:suggestion
+dotnet_diagnostic.S1075.severity = silent
+dotnet_diagnostic.SS3358.severity = suggestion
+dotnet_diagnostic.MA0007.severity = silent
+dotnet_diagnostic.MA0075.severity = silent
+
+# S3358: Ternary operators should not be nested
+dotnet_diagnostic.S3358.severity = suggestion
+
+# S6678: Use PascalCase for named placeholders
+dotnet_diagnostic.S6678.severity = none
+
+# S6605: Collection-specific "Exists" method should be used instead of the "Any" extension
+dotnet_diagnostic.S6605.severity = none
+
+# S6667: Logging in a catch clause should pass the caught exception as a parameter.
+dotnet_diagnostic.S6667.severity = suggestion
+
+# IDE0290: Use primary constructor
+csharp_style_prefer_primary_constructors = false
+
+# S3267: Loops should be simplified with "LINQ" expressions
+dotnet_diagnostic.S3267.severity = silent
+
+# MA0048: File name must match type name
+dotnet_diagnostic.MA0048.severity = silent

MareSynchronos/FileCache/CacheMonitor.cs

@@ -0,0 +1,859 @@
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+using System.Collections.Immutable;
+using System.Runtime.CompilerServices;
+
+namespace MareSynchronos.FileCache;
+
+public sealed class CacheMonitor : DisposableMediatorSubscriberBase
+{
+    private readonly MareConfigService _configService;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly FileCompactor _fileCompactor;
+    private readonly FileCacheManager _fileDbManager;
+    private readonly IpcManager _ipcManager;
+    private readonly PerformanceCollectorService _performanceCollector;
+    private long _currentFileProgress = 0;
+    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"];
+
+    public CacheMonitor(ILogger<CacheMonitor> logger, IpcManager ipcManager, MareConfigService configService,
+        FileCacheManager fileDbManager, MareMediator mediator, PerformanceCollectorService performanceCollector, DalamudUtilService dalamudUtil,
+        FileCompactor fileCompactor) : base(logger, mediator)
+    {
+        _ipcManager = ipcManager;
+        _configService = configService;
+        _fileDbManager = fileDbManager;
+        _performanceCollector = performanceCollector;
+        _dalamudUtil = dalamudUtil;
+        _fileCompactor = fileCompactor;
+        Mediator.Subscribe<PenumbraInitializedMessage>(this, (_) =>
+        {
+            StartPenumbraWatcher(_ipcManager.Penumbra.ModDirectory);
+            StartMareWatcher(configService.Current.CacheFolder);
+            StartSubstWatcher(_fileDbManager.SubstFolder);
+            InvokeScan();
+        });
+        Mediator.Subscribe<HaltScanMessage>(this, (msg) => HaltScan(msg.Source));
+        Mediator.Subscribe<ResumeScanMessage>(this, (msg) => ResumeScan(msg.Source));
+        Mediator.Subscribe<DalamudLoginMessage>(this, (_) =>
+        {
+            StartMareWatcher(configService.Current.CacheFolder);
+            StartSubstWatcher(_fileDbManager.SubstFolder);
+            StartPenumbraWatcher(_ipcManager.Penumbra.ModDirectory);
+            InvokeScan();
+        });
+        Mediator.Subscribe<PenumbraDirectoryChangedMessage>(this, (msg) =>
+        {
+            StartPenumbraWatcher(msg.ModDirectory);
+            InvokeScan();
+        });
+        if (_ipcManager.Penumbra.APIAvailable && !string.IsNullOrEmpty(_ipcManager.Penumbra.ModDirectory))
+        {
+            StartPenumbraWatcher(_ipcManager.Penumbra.ModDirectory);
+        }
+        if (configService.Current.HasValidSetup())
+        {
+            StartMareWatcher(configService.Current.CacheFolder);
+            StartSubstWatcher(_fileDbManager.SubstFolder);
+            InvokeScan();
+        }
+
+        var token = _periodicCalculationTokenSource.Token;
+        _ = Task.Run(async () =>
+        {
+            Logger.LogInformation("Starting Periodic Storage Directory Calculation Task");
+            var token = _periodicCalculationTokenSource.Token;
+            while (!token.IsCancellationRequested)
+            {
+                try
+                {
+                    while (_dalamudUtil.IsOnFrameworkThread && !token.IsCancellationRequested)
+                    {
+                        await Task.Delay(1).ConfigureAwait(false);
+                    }
+
+                    RecalculateFileCacheSize(token);
+                }
+                catch
+                {
+                    // ignore
+                }
+                await Task.Delay(TimeSpan.FromMinutes(1), token).ConfigureAwait(false);
+            }
+        }, token);
+    }
+
+    public long CurrentFileProgress => _currentFileProgress;
+    public long FileCacheSize { get; set; }
+    public long FileCacheDriveFree { get; set; }
+    public ConcurrentDictionary<string, StrongBox<int>> HaltScanLocks { get; set; } = new(StringComparer.Ordinal);
+    public bool IsScanRunning => CurrentFileProgress > 0 || TotalFiles > 0;
+    public long TotalFiles { get; private set; }
+    public long TotalFilesStorage { get; private set; }
+
+    public void HaltScan(string source)
+    {
+        HaltScanLocks.TryAdd(source, new(0));
+        Interlocked.Increment(ref HaltScanLocks[source].Value);
+    }
+
+    record WatcherChange(WatcherChangeTypes ChangeType, string? OldPath = null);
+    private readonly Dictionary<string, WatcherChange> _watcherChanges = new Dictionary<string, WatcherChange>(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, WatcherChange> _mareChanges = new Dictionary<string, WatcherChange>(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, WatcherChange> _substChanges = new Dictionary<string, WatcherChange>(StringComparer.OrdinalIgnoreCase);
+
+    public void StopMonitoring()
+    {
+        Logger.LogInformation("Stopping monitoring of Penumbra and Mare storage folders");
+        MareWatcher?.Dispose();
+        SubstWatcher?.Dispose();
+        PenumbraWatcher?.Dispose();
+        MareWatcher = null;
+        SubstWatcher = null;
+        PenumbraWatcher = null;
+    }
+
+    public bool StorageisNTFS { get; private set; } = false;
+
+    public void StartMareWatcher(string? marePath)
+    {
+        MareWatcher?.Dispose();
+        if (string.IsNullOrEmpty(marePath) || !Directory.Exists(marePath))
+        {
+            MareWatcher = null;
+            Logger.LogWarning("Mare file path is not set, cannot start the FSW for Mare.");
+            return;
+        }
+
+        DriveInfo di = new(new DirectoryInfo(_configService.Current.CacheFolder).Root.FullName);
+        StorageisNTFS = string.Equals("NTFS", di.DriveFormat, StringComparison.OrdinalIgnoreCase);
+        Logger.LogInformation("Mare Storage is on NTFS drive: {isNtfs}", StorageisNTFS);
+
+        Logger.LogDebug("Initializing Mare FSW on {path}", marePath);
+        MareWatcher = new()
+        {
+            Path = marePath,
+            InternalBufferSize = 8388608,
+            NotifyFilter = NotifyFilters.CreationTime
+                | NotifyFilters.LastWrite
+                | NotifyFilters.FileName
+                | NotifyFilters.DirectoryName
+                | NotifyFilters.Size,
+            Filter = "*.*",
+            IncludeSubdirectories = false,
+        };
+
+        MareWatcher.Deleted += MareWatcher_FileChanged;
+        MareWatcher.Created += MareWatcher_FileChanged;
+        MareWatcher.EnableRaisingEvents = true;
+    }
+
+    public void StartSubstWatcher(string? substPath)
+    {
+        SubstWatcher?.Dispose();
+        if (string.IsNullOrEmpty(substPath))
+        {
+            SubstWatcher = null;
+            Logger.LogWarning("Mare file path is not set, cannot start the FSW for Mare.");
+            return;
+        }
+
+        try
+        {
+            if (!Directory.Exists(substPath))
+                Directory.CreateDirectory(substPath);
+        }
+        catch
+        {
+            Logger.LogWarning("Could not create subst directory at {path}.", substPath);
+            return;
+        }
+
+        Logger.LogDebug("Initializing Subst FSW on {path}", substPath);
+        SubstWatcher = new()
+        {
+            Path = substPath,
+            InternalBufferSize = 8388608,
+            NotifyFilter = NotifyFilters.CreationTime
+                | NotifyFilters.LastWrite
+                | NotifyFilters.FileName
+                | NotifyFilters.DirectoryName
+                | NotifyFilters.Size,
+            Filter = "*.*",
+            IncludeSubdirectories = false,
+        };
+
+        SubstWatcher.Deleted += SubstWatcher_FileChanged;
+        SubstWatcher.Created += SubstWatcher_FileChanged;
+        SubstWatcher.EnableRaisingEvents = true;
+    }
+
+    private void MareWatcher_FileChanged(object sender, FileSystemEventArgs e)
+    {
+        Logger.LogTrace("Mare FSW: FileChanged: {change} => {path}", e.ChangeType, e.FullPath);
+
+        if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+
+        lock (_mareChanges)
+        {
+            _mareChanges[e.FullPath] = new(e.ChangeType);
+        }
+
+        _ = MareWatcherExecution();
+    }
+
+    private void SubstWatcher_FileChanged(object sender, FileSystemEventArgs e)
+    {
+        Logger.LogTrace("Subst FSW: FileChanged: {change} => {path}", e.ChangeType, e.FullPath);
+
+        if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+
+        lock (_substChanges)
+        {
+            _substChanges[e.FullPath] = new(e.ChangeType);
+        }
+
+        _ = SubstWatcherExecution();
+    }
+
+    public void StartPenumbraWatcher(string? penumbraPath)
+    {
+        PenumbraWatcher?.Dispose();
+        if (string.IsNullOrEmpty(penumbraPath))
+        {
+            PenumbraWatcher = null;
+            Logger.LogWarning("Penumbra is not connected or the path is not set, cannot start FSW for Penumbra.");
+            return;
+        }
+
+        Logger.LogDebug("Initializing Penumbra FSW on {path}", penumbraPath);
+        PenumbraWatcher = new()
+        {
+            Path = penumbraPath,
+            InternalBufferSize = 8388608,
+            NotifyFilter = NotifyFilters.CreationTime
+                | NotifyFilters.LastWrite
+                | NotifyFilters.FileName
+                | NotifyFilters.DirectoryName
+                | NotifyFilters.Size,
+            Filter = "*.*",
+            IncludeSubdirectories = true
+        };
+
+        PenumbraWatcher.Deleted += Fs_Changed;
+        PenumbraWatcher.Created += Fs_Changed;
+        PenumbraWatcher.Changed += Fs_Changed;
+        PenumbraWatcher.Renamed += Fs_Renamed;
+        PenumbraWatcher.EnableRaisingEvents = true;
+    }
+
+    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 (e.ChangeType is not (WatcherChangeTypes.Changed or WatcherChangeTypes.Deleted or WatcherChangeTypes.Created))
+            return;
+
+        lock (_watcherChanges)
+        {
+            _watcherChanges[e.FullPath] = new(e.ChangeType);
+        }
+
+        Logger.LogTrace("FSW {event}: {path}", e.ChangeType, e.FullPath);
+
+        _ = PenumbraWatcherExecution();
+    }
+
+    private void Fs_Renamed(object sender, RenamedEventArgs e)
+    {
+        if (Directory.Exists(e.FullPath))
+        {
+            var directoryFiles = Directory.GetFiles(e.FullPath, "*.*", SearchOption.AllDirectories);
+            lock (_watcherChanges)
+            {
+                foreach (var file in directoryFiles)
+                {
+                    if (!AllowedFileExtensions.Any(ext => file.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) continue;
+                    var oldPath = file.Replace(e.FullPath, e.OldFullPath, StringComparison.OrdinalIgnoreCase);
+
+                    _watcherChanges.Remove(oldPath);
+                    _watcherChanges[file] = new(WatcherChangeTypes.Renamed, oldPath);
+                    Logger.LogTrace("FSW Renamed: {path} -> {new}", oldPath, file);
+
+                }
+            }
+        }
+        else
+        {
+            if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+
+            lock (_watcherChanges)
+            {
+                _watcherChanges.Remove(e.OldFullPath);
+                _watcherChanges[e.FullPath] = new(WatcherChangeTypes.Renamed, e.OldFullPath);
+            }
+
+            Logger.LogTrace("FSW Renamed: {path} -> {new}", e.OldFullPath, e.FullPath);
+        }
+
+        _ = PenumbraWatcherExecution();
+    }
+
+    private CancellationTokenSource _penumbraFswCts = new();
+    private CancellationTokenSource _mareFswCts = new();
+    private CancellationTokenSource _substFswCts = new();
+    public FileSystemWatcher? PenumbraWatcher { get; private set; }
+    public FileSystemWatcher? MareWatcher { get; private set; }
+    public FileSystemWatcher? SubstWatcher { get; private set; }
+
+    private async Task MareWatcherExecution()
+    {
+        _mareFswCts = _mareFswCts.CancelRecreate();
+        var token = _mareFswCts.Token;
+        var delay = TimeSpan.FromSeconds(5);
+        Dictionary<string, WatcherChange> changes;
+        lock (_mareChanges)
+            changes = _mareChanges.ToDictionary(t => t.Key, t => t.Value, StringComparer.Ordinal);
+        try
+        {
+            do
+            {
+                await Task.Delay(delay, token).ConfigureAwait(false);
+            } while (HaltScanLocks.Any(f => f.Value.Value > 0));
+        }
+        catch (TaskCanceledException)
+        {
+            return;
+        }
+
+        lock (_mareChanges)
+        {
+            foreach (var key in changes.Keys)
+            {
+                _mareChanges.Remove(key);
+            }
+        }
+
+        HandleChanges(changes);
+    }
+
+    private async Task SubstWatcherExecution()
+    {
+        _substFswCts = _substFswCts.CancelRecreate();
+        var token = _substFswCts.Token;
+        var delay = TimeSpan.FromSeconds(5);
+        Dictionary<string, WatcherChange> changes;
+        lock (_substChanges)
+            changes = _substChanges.ToDictionary(t => t.Key, t => t.Value, StringComparer.Ordinal);
+        try
+        {
+            do
+            {
+                await Task.Delay(delay, token).ConfigureAwait(false);
+            } while (HaltScanLocks.Any(f => f.Value.Value > 0));
+        }
+        catch (TaskCanceledException)
+        {
+            return;
+        }
+
+        lock (_substChanges)
+        {
+            foreach (var key in changes.Keys)
+            {
+                _substChanges.Remove(key);
+            }
+        }
+
+        HandleChanges(changes);
+    }
+
+    public void ClearSubstStorage()
+    {
+        var substDir = _fileDbManager.SubstFolder;
+        var allSubstFiles = Directory.GetFiles(substDir, "*.*", SearchOption.TopDirectoryOnly)
+                                .Where(f =>
+                                {
+                                    var val = f.Split('\\')[^1];
+                                    return val.Length == 40 || (val.Split('.').FirstOrDefault()?.Length ?? 0) == 40
+                                        || val.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase);
+                                });
+        if (SubstWatcher != null)
+            SubstWatcher.EnableRaisingEvents = false;
+
+        Dictionary<string, WatcherChange> changes = _substChanges.ToDictionary(t => t.Key, t => new WatcherChange(WatcherChangeTypes.Deleted, t.Key), StringComparer.Ordinal);
+
+        foreach (var file in allSubstFiles)
+        {
+            try
+            {
+                File.Delete(file);
+            }
+            catch { }
+        }
+
+        HandleChanges(changes);
+
+        if (SubstWatcher != null)
+            SubstWatcher.EnableRaisingEvents = true;
+    }
+
+    public void DeleteSubstOriginals()
+    {
+        var cacheDir = _configService.Current.CacheFolder;
+        var substDir = _fileDbManager.SubstFolder;
+        var allSubstFiles = Directory.GetFiles(substDir, "*.*", SearchOption.TopDirectoryOnly)
+                                .Where(f =>
+                                {
+                                    var val = f.Split('\\')[^1];
+                                    return val.Length == 40 || (val.Split('.').FirstOrDefault()?.Length ?? 0) == 40
+                                        || val.EndsWith(".tmp", StringComparison.OrdinalIgnoreCase);
+                                });
+
+        foreach (var substFile in allSubstFiles)
+        {
+            var cacheFile = Path.Join(cacheDir, Path.GetFileName(substFile));
+            try
+            {
+                if (File.Exists(cacheFile))
+                    File.Delete(cacheFile);
+            }
+            catch { }
+        }
+    }
+
+    private void HandleChanges(Dictionary<string, WatcherChange> changes)
+    {
+        lock (_fileDbManager)
+        {
+            var deletedEntries = changes.Where(c => c.Value.ChangeType == WatcherChangeTypes.Deleted).Select(c => c.Key);
+            var renamedEntries = changes.Where(c => c.Value.ChangeType == WatcherChangeTypes.Renamed);
+            var remainingEntries = changes.Where(c => c.Value.ChangeType != WatcherChangeTypes.Deleted).Select(c => c.Key);
+
+            foreach (var entry in deletedEntries)
+            {
+                Logger.LogDebug("FSW Change: Deletion - {val}", entry);
+            }
+
+            foreach (var entry in renamedEntries)
+            {
+                Logger.LogDebug("FSW Change: Renamed - {oldVal} => {val}", entry.Value.OldPath, entry.Key);
+            }
+
+            foreach (var entry in remainingEntries)
+            {
+                Logger.LogDebug("FSW Change: Creation or Change - {val}", entry);
+            }
+
+            var allChanges = deletedEntries
+                .Concat(renamedEntries.Select(c => c.Value.OldPath!))
+                .Concat(renamedEntries.Select(c => c.Key))
+                .Concat(remainingEntries)
+                .ToArray();
+
+            _ = _fileDbManager.GetFileCachesByPaths(allChanges);
+
+            _fileDbManager.WriteOutFullCsv();
+        }
+    }
+
+    private async Task PenumbraWatcherExecution()
+    {
+        _penumbraFswCts = _penumbraFswCts.CancelRecreate();
+        var token = _penumbraFswCts.Token;
+        Dictionary<string, WatcherChange> changes;
+        lock (_watcherChanges)
+            changes = _watcherChanges.ToDictionary(t => t.Key, t => t.Value, StringComparer.Ordinal);
+        var delay = TimeSpan.FromSeconds(10);
+        try
+        {
+            do
+            {
+                await Task.Delay(delay, token).ConfigureAwait(false);
+            } while (HaltScanLocks.Any(f => f.Value.Value > 0));
+        }
+        catch (TaskCanceledException)
+        {
+            return;
+        }
+
+        lock (_watcherChanges)
+        {
+            foreach (var key in changes.Keys)
+            {
+                _watcherChanges.Remove(key);
+            }
+        }
+
+        HandleChanges(changes);
+    }
+
+    public void InvokeScan()
+    {
+        TotalFiles = 0;
+        _currentFileProgress = 0;
+        _scanCancellationTokenSource = _scanCancellationTokenSource?.CancelRecreate() ?? new CancellationTokenSource();
+        var token = _scanCancellationTokenSource.Token;
+        _ = Task.Run(async () =>
+        {
+            Logger.LogDebug("Starting Full File Scan");
+            TotalFiles = 0;
+            _currentFileProgress = 0;
+            while (_dalamudUtil.IsOnFrameworkThread)
+            {
+                Logger.LogWarning("Scanner is on framework, waiting for leaving thread before continuing");
+                await Task.Delay(250, token).ConfigureAwait(false);
+            }
+
+            Thread scanThread = new(() =>
+            {
+                try
+                {
+                    _performanceCollector.LogPerformance(this, $"FullFileScan", () => FullFileScan(token));
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogError(ex, "Error during Full File Scan");
+                }
+            })
+            {
+                Priority = ThreadPriority.Lowest,
+                IsBackground = true
+            };
+            scanThread.Start();
+            while (scanThread.IsAlive)
+            {
+                await Task.Delay(250).ConfigureAwait(false);
+            }
+            TotalFiles = 0;
+            _currentFileProgress = 0;
+        }, token);
+    }
+
+    public void RecalculateFileCacheSize(CancellationToken token)
+    {
+        if (string.IsNullOrEmpty(_configService.Current.CacheFolder) || !Directory.Exists(_configService.Current.CacheFolder))
+        {
+            FileCacheSize = 0;
+            return;
+        }
+
+        FileCacheSize = -1;
+        DriveInfo di = new(new DirectoryInfo(_configService.Current.CacheFolder).Root.FullName);
+        try
+        {
+            FileCacheDriveFree = di.AvailableFreeSpace;
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Could not determine drive size for Storage Folder {folder}", _configService.Current.CacheFolder);
+        }
+
+        var files = Directory.EnumerateFiles(_configService.Current.CacheFolder)
+            .Concat(Directory.EnumerateFiles(_fileDbManager.SubstFolder))
+            .Select(f => new FileInfo(f))
+            .OrderBy(f => f.LastAccessTime).ToList();
+        FileCacheSize = files
+            .Sum(f =>
+            {
+                token.ThrowIfCancellationRequested();
+
+                try
+                {
+                    return _fileCompactor.GetFileSizeOnDisk(f, StorageisNTFS);
+                }
+                catch
+                {
+                    return 0;
+                }
+            });
+
+        var maxCacheInBytes = (long)(_configService.Current.MaxLocalCacheInGiB * 1024d * 1024d * 1024d);
+
+        if (FileCacheSize < maxCacheInBytes) return;
+
+        var substDir = _fileDbManager.SubstFolder;
+
+        var maxCacheBuffer = maxCacheInBytes * 0.05d;
+        while (FileCacheSize > maxCacheInBytes - (long)maxCacheBuffer)
+        {
+            var oldestFile = files[0];
+            FileCacheSize -= _fileCompactor.GetFileSizeOnDisk(oldestFile);
+            File.Delete(oldestFile.FullName);
+            files.Remove(oldestFile);
+        }
+    }
+
+    public void ResetLocks()
+    {
+        HaltScanLocks.Clear();
+    }
+
+    public void ResumeScan(string source)
+    {
+        HaltScanLocks.TryAdd(source, new(0));
+        Interlocked.Decrement(ref HaltScanLocks[source].Value);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        _scanCancellationTokenSource?.Cancel();
+        PenumbraWatcher?.Dispose();
+        MareWatcher?.Dispose();
+        SubstWatcher?.Dispose();
+        _penumbraFswCts?.CancelDispose();
+        _mareFswCts?.CancelDispose();
+        _substFswCts?.CancelDispose();
+        _periodicCalculationTokenSource?.CancelDispose();
+    }
+
+    private void FullFileScan(CancellationToken ct)
+    {
+        TotalFiles = 1;
+        var penumbraDir = _ipcManager.Penumbra.ModDirectory;
+        bool penDirExists = true;
+        bool cacheDirExists = true;
+        var substDir = _fileDbManager.SubstFolder;
+        if (string.IsNullOrEmpty(penumbraDir) || !Directory.Exists(penumbraDir))
+        {
+            penDirExists = false;
+            Logger.LogWarning("Penumbra directory is not set or does not exist.");
+        }
+        if (string.IsNullOrEmpty(_configService.Current.CacheFolder) || !Directory.Exists(_configService.Current.CacheFolder))
+        {
+            cacheDirExists = false;
+            Logger.LogWarning("Elezen Cache directory is not set or does not exist.");
+        }
+        if (!penDirExists || !cacheDirExists)
+        {
+            return;
+        }
+
+        try
+        {
+            if (!Directory.Exists(substDir))
+                Directory.CreateDirectory(substDir);
+        }
+        catch
+        {
+            Logger.LogWarning("Could not create subst directory at {path}.", substDir);
+        }
+
+        var previousThreadPriority = Thread.CurrentThread.Priority;
+        Thread.CurrentThread.Priority = ThreadPriority.Lowest;
+        Logger.LogDebug("Getting files from {penumbra} and {storage}", penumbraDir, _configService.Current.CacheFolder);
+
+        Dictionary<string, string[]> penumbraFiles = new(StringComparer.Ordinal);
+        foreach (var folder in Directory.EnumerateDirectories(penumbraDir!))
+        {
+            try
+            {
+                penumbraFiles[folder] =
+                [
+                    .. Directory.GetFiles(folder, "*.*", SearchOption.AllDirectories)
+                                            .AsParallel()
+                                            .Where(f => AllowedFileExtensions.Any(e => f.EndsWith(e, StringComparison.OrdinalIgnoreCase))
+                                                && !f.Contains(@"\bg\", StringComparison.OrdinalIgnoreCase)
+                                                && !f.Contains(@"\bgcommon\", StringComparison.OrdinalIgnoreCase)
+                                                && !f.Contains(@"\ui\", StringComparison.OrdinalIgnoreCase)),
+                ];
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning(ex, "Could not enumerate path {path}", folder);
+            }
+            Thread.Sleep(50);
+            if (ct.IsCancellationRequested) return;
+        }
+
+        var allCacheFiles = Directory.GetFiles(_configService.Current.CacheFolder, "*.*", SearchOption.TopDirectoryOnly)
+                                .Concat(Directory.GetFiles(substDir, "*.*", SearchOption.TopDirectoryOnly))
+                                .AsParallel()
+                                .Where(f =>
+                                {
+                                    var val = f.Split('\\')[^1];
+                                    return val.Length == 40 || (val.Split('.').FirstOrDefault()?.Length ?? 0) == 40;
+                                });
+
+        if (ct.IsCancellationRequested) return;
+
+        var allScannedFiles = (penumbraFiles.SelectMany(k => k.Value))
+            .Concat(allCacheFiles)
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(t => t.ToLowerInvariant(), t => false, StringComparer.OrdinalIgnoreCase);
+
+        TotalFiles = allScannedFiles.Count;
+        Thread.CurrentThread.Priority = previousThreadPriority;
+
+        Thread.Sleep(TimeSpan.FromSeconds(2));
+
+        if (ct.IsCancellationRequested) return;
+
+        // scan files from database
+        var threadCount = Math.Clamp((int)(Environment.ProcessorCount / 2.0f), 2, 8);
+
+        List<FileCacheEntity> entitiesToRemove = [];
+        List<FileCacheEntity> entitiesToUpdate = [];
+        Lock sync = new();
+        Thread[] workerThreads = new Thread[threadCount];
+
+        ConcurrentQueue<FileCacheEntity> fileCaches = new(_fileDbManager.GetAllFileCaches());
+
+        TotalFilesStorage = fileCaches.Count;
+
+        for (int i = 0; i < threadCount; i++)
+        {
+            Logger.LogTrace("Creating Thread {i}", i);
+            workerThreads[i] = new((tcounter) =>
+            {
+                var threadNr = (int)tcounter!;
+                Logger.LogTrace("Spawning Worker Thread {i}", threadNr);
+                while (!ct.IsCancellationRequested && fileCaches.TryDequeue(out var workload))
+                {
+                    try
+                    {
+                        if (ct.IsCancellationRequested) return;
+
+                        if (!_ipcManager.Penumbra.APIAvailable)
+                        {
+                            Logger.LogWarning("Penumbra not available");
+                            return;
+                        }
+
+                        var validatedCacheResult = _fileDbManager.ValidateFileCacheEntity(workload);
+                        if (validatedCacheResult.State != FileState.RequireDeletion)
+                        {
+                            lock (sync) { allScannedFiles[validatedCacheResult.FileCache.ResolvedFilepath] = true; }
+                        }
+                        if (validatedCacheResult.State == FileState.RequireUpdate)
+                        {
+                            Logger.LogTrace("To update: {path}", validatedCacheResult.FileCache.ResolvedFilepath);
+                            lock (sync) { entitiesToUpdate.Add(validatedCacheResult.FileCache); }
+                        }
+                        else if (validatedCacheResult.State == FileState.RequireDeletion)
+                        {
+                            Logger.LogTrace("To delete: {path}", validatedCacheResult.FileCache.ResolvedFilepath);
+                            lock (sync) { entitiesToRemove.Add(validatedCacheResult.FileCache); }
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.LogWarning(ex, "Failed validating {path}", workload.ResolvedFilepath);
+                    }
+                    Interlocked.Increment(ref _currentFileProgress);
+                }
+
+                Logger.LogTrace("Ending Worker Thread {i}", threadNr);
+            })
+            {
+                Priority = ThreadPriority.Lowest,
+                IsBackground = true
+            };
+            workerThreads[i].Start(i);
+        }
+
+        while (!ct.IsCancellationRequested && workerThreads.Any(u => u.IsAlive))
+        {
+            Thread.Sleep(1000);
+        }
+
+        if (ct.IsCancellationRequested) return;
+
+        Logger.LogTrace("Threads exited");
+
+        if (!_ipcManager.Penumbra.APIAvailable)
+        {
+            Logger.LogWarning("Penumbra not available");
+            return;
+        }
+
+        if (entitiesToUpdate.Any() || entitiesToRemove.Any())
+        {
+            foreach (var entity in entitiesToUpdate)
+            {
+                _fileDbManager.UpdateHashedFile(entity);
+            }
+
+            foreach (var entity in entitiesToRemove)
+            {
+                _fileDbManager.RemoveHashedFile(entity.Hash, entity.PrefixedFilePath);
+            }
+
+            _fileDbManager.WriteOutFullCsv();
+        }
+
+        Logger.LogTrace("Scanner validated existing db files");
+
+        if (!_ipcManager.Penumbra.APIAvailable)
+        {
+            Logger.LogWarning("Penumbra not available");
+            return;
+        }
+
+        if (ct.IsCancellationRequested) return;
+
+        // scan new files
+        if (allScannedFiles.Any(c => !c.Value))
+        {
+            Parallel.ForEach(allScannedFiles.Where(c => !c.Value).Select(c => c.Key),
+                new ParallelOptions()
+                {
+                    MaxDegreeOfParallelism = threadCount,
+                    CancellationToken = ct
+                }, (cachePath) =>
+                {
+                    if (ct.IsCancellationRequested) return;
+
+                    if (!_ipcManager.Penumbra.APIAvailable)
+                    {
+                        Logger.LogWarning("Penumbra not available");
+                        return;
+                    }
+
+                    try
+                    {
+                        var entry = _fileDbManager.CreateFileEntry(cachePath);
+                        if (entry == null)
+                        {
+                            if (cachePath.StartsWith(substDir, StringComparison.Ordinal))
+                                _ = _fileDbManager.CreateSubstEntry(cachePath);
+                            else
+                                _ = _fileDbManager.CreateCacheEntry(cachePath);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        Logger.LogWarning(ex, "Failed adding {file}", cachePath);
+                    }
+
+                    Interlocked.Increment(ref _currentFileProgress);
+                });
+
+            Logger.LogTrace("Scanner added {notScanned} new files to db", allScannedFiles.Count(c => !c.Value));
+        }
+
+        Logger.LogDebug("Scan complete");
+        TotalFiles = 0;
+        _currentFileProgress = 0;
+        entitiesToRemove.Clear();
+        allScannedFiles.Clear();
+
+        if (!_configService.Current.InitialScanComplete)
+        {
+            _configService.Current.InitialScanComplete = true;
+            _configService.Save();
+            StartMareWatcher(_configService.Current.CacheFolder);
+            StartSubstWatcher(_fileDbManager.SubstFolder);
+            StartPenumbraWatcher(penumbraDir);
+        }
+    }
+}

MareSynchronos/FileCache/FileCacheEntity.cs

@@ -0,0 +1,30 @@
+#nullable disable
+
+namespace MareSynchronos.FileCache;
+
+public class FileCacheEntity
+{
+    public FileCacheEntity(string hash, string path, string lastModifiedDateTicks, long? size = null, long? compressedSize = null)
+    {
+        Size = size;
+        CompressedSize = compressedSize;
+        Hash = hash;
+        PrefixedFilePath = path;
+        LastModifiedDateTicks = lastModifiedDateTicks;
+    }
+
+    public long? CompressedSize { get; set; }
+    public string CsvEntry => $"{Hash}{FileCacheManager.CsvSplit}{PrefixedFilePath}{FileCacheManager.CsvSplit}{LastModifiedDateTicks}|{Size ?? -1}|{CompressedSize ?? -1}";
+    public string Hash { get; set; }
+    public bool IsCacheEntry => PrefixedFilePath.StartsWith(FileCacheManager.CachePrefix, StringComparison.OrdinalIgnoreCase);
+    public bool IsSubstEntry => PrefixedFilePath.StartsWith(FileCacheManager.SubstPrefix, StringComparison.OrdinalIgnoreCase);
+    public string LastModifiedDateTicks { get; set; }
+    public string PrefixedFilePath { get; init; }
+    public string ResolvedFilepath { get; private set; } = string.Empty;
+    public long? Size { get; set; }
+
+    public void SetResolvedFilePath(string filePath)
+    {
+        ResolvedFilepath = filePath.ToLowerInvariant().Replace("\\\\", "\\", StringComparison.Ordinal);
+    }
+}

MareSynchronos/FileCache/FileCacheManager.cs

@@ -0,0 +1,556 @@
+using Dalamud.Utility;
+using K4os.Compression.LZ4.Streams;
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+using System.Globalization;
+using System.Text;
+
+namespace MareSynchronos.FileCache;
+
+public sealed class FileCacheManager : IHostedService
+{
+    public const string CachePrefix = "{cache}";
+    public const string CsvSplit = "|";
+    public const string PenumbraPrefix = "{penumbra}";
+    public const string SubstPrefix = "{subst}";
+    public const string SubstPath = "subst";
+    public string CacheFolder => _configService.Current.CacheFolder;
+    public string SubstFolder => CacheFolder.IsNullOrEmpty() ? string.Empty : CacheFolder.ToLowerInvariant().TrimEnd('\\') + "\\" + SubstPath;
+    private readonly MareConfigService _configService;
+    private readonly MareMediator _mareMediator;
+    private readonly string _csvPath;
+    private readonly ConcurrentDictionary<string, List<FileCacheEntity>> _fileCaches = new(StringComparer.Ordinal);
+    private readonly SemaphoreSlim _getCachesByPathsSemaphore = new(1, 1);
+    private readonly Lock _fileWriteLock = new();
+    private readonly IpcManager _ipcManager;
+    private readonly ILogger<FileCacheManager> _logger;
+
+    public FileCacheManager(ILogger<FileCacheManager> logger, IpcManager ipcManager, MareConfigService configService, MareMediator mareMediator)
+    {
+        _logger = logger;
+        _ipcManager = ipcManager;
+        _configService = configService;
+        _mareMediator = mareMediator;
+        _csvPath = Path.Combine(configService.ConfigurationDirectory, "FileCache.csv");
+    }
+
+    private string CsvBakPath => _csvPath + ".bak";
+
+    public FileCacheEntity? CreateCacheEntry(string path, string? hash = null)
+    {
+        FileInfo fi = new(path);
+        if (!fi.Exists) return null;
+        _logger.LogTrace("Creating cache entry for {path}", path);
+        var fullName = fi.FullName.ToLowerInvariant();
+        if (!fullName.Contains(_configService.Current.CacheFolder.ToLowerInvariant(), StringComparison.Ordinal)) return null;
+        string prefixedPath = fullName.Replace(_configService.Current.CacheFolder.ToLowerInvariant(), CachePrefix + "\\", StringComparison.Ordinal).Replace("\\\\", "\\", StringComparison.Ordinal);
+        if (hash != null)
+            return CreateFileCacheEntity(fi, prefixedPath, hash);
+        else
+            return CreateFileCacheEntity(fi, prefixedPath);
+    }
+
+    public FileCacheEntity? CreateSubstEntry(string path)
+    {
+        FileInfo fi = new(path);
+        if (!fi.Exists) return null;
+        _logger.LogTrace("Creating substitute entry for {path}", path);
+        var fullName = fi.FullName.ToLowerInvariant();
+        if (!fullName.Contains(SubstFolder, StringComparison.Ordinal)) return null;
+        string prefixedPath = fullName.Replace(SubstFolder, SubstPrefix + "\\", StringComparison.Ordinal).Replace("\\\\", "\\", StringComparison.Ordinal);
+        var fakeHash = Path.GetFileNameWithoutExtension(fi.FullName).ToUpperInvariant();
+        var result = CreateFileCacheEntity(fi, prefixedPath, fakeHash);
+        return result;
+    }
+
+    public FileCacheEntity? CreateFileEntry(string path)
+    {
+        FileInfo fi = new(path);
+        if (!fi.Exists) return null;
+        _logger.LogTrace("Creating file entry for {path}", path);
+        var fullName = fi.FullName.ToLowerInvariant();
+        if (!fullName.Contains(_ipcManager.Penumbra.ModDirectory!.ToLowerInvariant(), StringComparison.Ordinal)) return null;
+        string prefixedPath = fullName.Replace(_ipcManager.Penumbra.ModDirectory!.ToLowerInvariant(), PenumbraPrefix + "\\", StringComparison.Ordinal).Replace("\\\\", "\\", StringComparison.Ordinal);
+        return CreateFileCacheEntity(fi, prefixedPath);
+    }
+
+    public List<FileCacheEntity> GetAllFileCaches() => _fileCaches.Values.SelectMany(v => v).ToList();
+
+    public List<FileCacheEntity> GetAllFileCachesByHash(string hash, bool ignoreCacheEntries = false, bool validate = true)
+    {
+        List<FileCacheEntity> output = [];
+        if (_fileCaches.TryGetValue(hash, out var fileCacheEntities))
+        {
+            foreach (var fileCache in fileCacheEntities.Where(c => ignoreCacheEntries ? (!c.IsCacheEntry && !c.IsSubstEntry) : true).ToList())
+            {
+                if (!validate) output.Add(fileCache);
+                else
+                {
+                    var validated = GetValidatedFileCache(fileCache);
+                    if (validated != null) output.Add(validated);
+                }
+            }
+        }
+
+        return output;
+    }
+
+    public Task<List<FileCacheEntity>> ValidateLocalIntegrity(IProgress<(int, int, FileCacheEntity)> progress, CancellationToken cancellationToken)
+    {
+        _mareMediator.Publish(new HaltScanMessage(nameof(ValidateLocalIntegrity)));
+        _logger.LogInformation("Validating local storage");
+        var cacheEntries = _fileCaches.SelectMany(v => v.Value).Where(v => v.IsCacheEntry).ToList();
+        List<FileCacheEntity> brokenEntities = [];
+        int i = 0;
+        foreach (var fileCache in cacheEntries)
+        {
+            if (cancellationToken.IsCancellationRequested) break;
+            if (fileCache.IsSubstEntry) continue;
+
+            _logger.LogInformation("Validating {file}", fileCache.ResolvedFilepath);
+
+            progress.Report((i, cacheEntries.Count, fileCache));
+            i++;
+            if (!File.Exists(fileCache.ResolvedFilepath))
+            {
+                brokenEntities.Add(fileCache);
+                continue;
+            }
+
+            try
+            {
+                var computedHash = Crypto.GetFileHash(fileCache.ResolvedFilepath);
+                if (!string.Equals(computedHash, fileCache.Hash, StringComparison.Ordinal))
+                {
+                    _logger.LogInformation("Failed to validate {file}, got hash {hash}, expected hash {expectedHash}", fileCache.ResolvedFilepath, computedHash, fileCache.Hash);
+                    brokenEntities.Add(fileCache);
+                }
+            }
+            catch (Exception e)
+            {
+                _logger.LogWarning(e, "Error during validation of {file}", fileCache.ResolvedFilepath);
+                brokenEntities.Add(fileCache);
+            }
+        }
+
+        foreach (var brokenEntity in brokenEntities)
+        {
+            RemoveHashedFile(brokenEntity.Hash, brokenEntity.PrefixedFilePath);
+
+            try
+            {
+                File.Delete(brokenEntity.ResolvedFilepath);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Could not delete {file}", brokenEntity.ResolvedFilepath);
+            }
+        }
+
+        _mareMediator.Publish(new ResumeScanMessage(nameof(ValidateLocalIntegrity)));
+        return Task.FromResult(brokenEntities);
+    }
+
+    public string GetCacheFilePath(string hash, string extension)
+    {
+        return Path.Combine(_configService.Current.CacheFolder, hash + "." + extension);
+    }
+
+    public string GetSubstFilePath(string hash, string extension)
+    {
+        return Path.Combine(SubstFolder, hash + "." + extension);
+    }
+
+    public async Task<(string, byte[])> GetCompressedFileData(string fileHash, CancellationToken uploadToken)
+    {
+        var fileCache = GetFileCacheByHash(fileHash)!;
+        using var fs = File.OpenRead(fileCache.ResolvedFilepath);
+        var ms = new MemoryStream(64 * 1024);
+        using var encstream = LZ4Stream.Encode(ms, new LZ4EncoderSettings(){CompressionLevel=K4os.Compression.LZ4.LZ4Level.L09_HC});
+        await fs.CopyToAsync(encstream, uploadToken).ConfigureAwait(false);
+        encstream.Close();
+        fileCache.CompressedSize = encstream.Length;
+        return (fileHash, ms.ToArray());
+    }
+
+    public FileCacheEntity? GetFileCacheByHash(string hash, bool preferSubst = false)
+    {
+        var caches = GetFileCachesByHash(hash);
+        if (preferSubst && caches.Subst != null)
+            return caches.Subst;
+        return caches.Penumbra ?? caches.Cache;
+    }
+
+    public (FileCacheEntity? Penumbra, FileCacheEntity? Cache, FileCacheEntity? Subst) GetFileCachesByHash(string hash)
+    {
+        (FileCacheEntity? Penumbra, FileCacheEntity? Cache, FileCacheEntity? Subst) result = (null, null, null);
+        if (_fileCaches.TryGetValue(hash, out var hashes))
+        {
+            result.Penumbra = hashes.Where(p => p.PrefixedFilePath.StartsWith(PenumbraPrefix, StringComparison.Ordinal)).Select(GetValidatedFileCache).FirstOrDefault();
+            result.Cache = hashes.Where(p => p.PrefixedFilePath.StartsWith(CachePrefix, StringComparison.Ordinal)).Select(GetValidatedFileCache).FirstOrDefault();
+            result.Subst = hashes.Where(p => p.PrefixedFilePath.StartsWith(SubstPrefix, StringComparison.Ordinal)).Select(GetValidatedFileCache).FirstOrDefault();
+        }
+        return result;
+    }
+
+    private FileCacheEntity? GetFileCacheByPath(string path)
+    {
+        var cleanedPath = path.Replace("/", "\\", StringComparison.OrdinalIgnoreCase).ToLowerInvariant()
+            .Replace(_ipcManager.Penumbra.ModDirectory!.ToLowerInvariant(), "", StringComparison.OrdinalIgnoreCase);
+        var entry = _fileCaches.SelectMany(v => v.Value).FirstOrDefault(f => f.ResolvedFilepath.EndsWith(cleanedPath, StringComparison.OrdinalIgnoreCase));
+
+        if (entry == null)
+        {
+            _logger.LogDebug("Found no entries for {path}", cleanedPath);
+            return CreateFileEntry(path);
+        }
+
+        var validatedCacheEntry = GetValidatedFileCache(entry);
+
+        return validatedCacheEntry;
+    }
+
+    public Dictionary<string, FileCacheEntity?> GetFileCachesByPaths(string[] paths)
+    {
+        _getCachesByPathsSemaphore.Wait();
+
+        try
+        {
+            var cleanedPaths = paths.Distinct(StringComparer.OrdinalIgnoreCase).ToDictionary(p => p,
+                p => p.Replace("/", "\\", StringComparison.OrdinalIgnoreCase)
+                    .Replace(_ipcManager.Penumbra.ModDirectory!, _ipcManager.Penumbra.ModDirectory!.EndsWith('\\') ? PenumbraPrefix + '\\' : PenumbraPrefix, StringComparison.OrdinalIgnoreCase)
+                    .Replace(SubstFolder, SubstPrefix, StringComparison.OrdinalIgnoreCase)
+                    .Replace(_configService.Current.CacheFolder, _configService.Current.CacheFolder.EndsWith('\\') ? CachePrefix + '\\' : CachePrefix, StringComparison.OrdinalIgnoreCase)
+                    .Replace("\\\\", "\\", StringComparison.Ordinal),
+                StringComparer.OrdinalIgnoreCase);
+
+            Dictionary<string, FileCacheEntity?> result = new(StringComparer.OrdinalIgnoreCase);
+
+            var dict = _fileCaches.SelectMany(f => f.Value)
+                .ToDictionary(d => d.PrefixedFilePath, d => d, StringComparer.OrdinalIgnoreCase);
+
+            foreach (var entry in cleanedPaths)
+            {
+                //_logger.LogDebug("Checking {path}", entry.Value);
+
+                if (dict.TryGetValue(entry.Value, out var entity))
+                {
+                    var validatedCache = GetValidatedFileCache(entity);
+                    result.Add(entry.Key, validatedCache);
+                }
+                else
+                {
+                    if (entry.Value.StartsWith(PenumbraPrefix, StringComparison.Ordinal))
+                        result.Add(entry.Key, CreateFileEntry(entry.Key));
+                    else if (entry.Value.StartsWith(SubstPrefix, StringComparison.Ordinal))
+                        result.Add(entry.Key, CreateSubstEntry(entry.Key));
+                    else if (entry.Value.StartsWith(CachePrefix, StringComparison.Ordinal))
+                        result.Add(entry.Key, CreateCacheEntry(entry.Key));
+                }
+            }
+
+            return result;
+        }
+        finally
+        {
+            _getCachesByPathsSemaphore.Release();
+        }
+    }
+
+    public void RemoveHashedFile(string hash, string prefixedFilePath)
+    {
+        if (_fileCaches.TryGetValue(hash, out var caches))
+        {
+            var removedCount = caches?.RemoveAll(c => string.Equals(c.PrefixedFilePath, prefixedFilePath, StringComparison.Ordinal));
+            _logger.LogTrace("Removed from DB: {count} file(s) with hash {hash} and file cache {path}", removedCount, hash, prefixedFilePath);
+
+            if (caches?.Count == 0)
+            {
+                _fileCaches.Remove(hash, out var _);
+            }
+        }
+    }
+
+    public void UpdateHashedFile(FileCacheEntity fileCache, bool computeProperties = true)
+    {
+        _logger.LogTrace("Updating hash for {path}", fileCache.ResolvedFilepath);
+        var oldHash = fileCache.Hash;
+        var prefixedPath = fileCache.PrefixedFilePath;
+        if (computeProperties)
+        {
+            var fi = new FileInfo(fileCache.ResolvedFilepath);
+            fileCache.Size = fi.Length;
+            fileCache.CompressedSize = null;
+            fileCache.Hash = Crypto.GetFileHash(fileCache.ResolvedFilepath);
+            fileCache.LastModifiedDateTicks = fi.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture);
+        }
+        RemoveHashedFile(oldHash, prefixedPath);
+        AddHashedFile(fileCache);
+    }
+
+    public (FileState State, FileCacheEntity FileCache) ValidateFileCacheEntity(FileCacheEntity fileCache)
+    {
+        fileCache = ReplacePathPrefixes(fileCache);
+        FileInfo fi = new(fileCache.ResolvedFilepath);
+        if (!fi.Exists)
+        {
+            return (FileState.RequireDeletion, fileCache);
+        }
+        if (!string.Equals(fi.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture), fileCache.LastModifiedDateTicks, StringComparison.Ordinal))
+        {
+            return (FileState.RequireUpdate, fileCache);
+        }
+
+        return (FileState.Valid, fileCache);
+    }
+
+    public void WriteOutFullCsv()
+    {
+        lock (_fileWriteLock)
+        {
+            StringBuilder sb = new();
+            foreach (var entry in _fileCaches.SelectMany(k => k.Value).OrderBy(f => f.PrefixedFilePath, StringComparer.OrdinalIgnoreCase))
+            {
+                sb.AppendLine(entry.CsvEntry);
+            }
+
+            if (File.Exists(_csvPath))
+            {
+                File.Copy(_csvPath, CsvBakPath, overwrite: true);
+            }
+
+            try
+            {
+                File.WriteAllText(_csvPath, sb.ToString());
+                File.Delete(CsvBakPath);
+            }
+            catch
+            {
+                File.WriteAllText(CsvBakPath, sb.ToString());
+            }
+        }
+    }
+
+    internal FileCacheEntity MigrateFileHashToExtension(FileCacheEntity fileCache, string ext)
+    {
+        try
+        {
+            RemoveHashedFile(fileCache.Hash, fileCache.PrefixedFilePath);
+            var extensionPath = fileCache.ResolvedFilepath.ToUpper(CultureInfo.InvariantCulture) + "." + ext;
+            File.Move(fileCache.ResolvedFilepath, extensionPath, overwrite: true);
+            var newHashedEntity = new FileCacheEntity(fileCache.Hash, fileCache.PrefixedFilePath + "." + ext, DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture));
+            newHashedEntity.SetResolvedFilePath(extensionPath);
+            AddHashedFile(newHashedEntity);
+            _logger.LogTrace("Migrated from {oldPath} to {newPath}", fileCache.ResolvedFilepath, newHashedEntity.ResolvedFilepath);
+            return newHashedEntity;
+        }
+        catch (Exception ex)
+        {
+            AddHashedFile(fileCache);
+            _logger.LogWarning(ex, "Failed to migrate entity {entity}", fileCache.PrefixedFilePath);
+            return fileCache;
+        }
+    }
+
+    private void AddHashedFile(FileCacheEntity fileCache)
+    {
+        if (!_fileCaches.TryGetValue(fileCache.Hash, out var entries) || entries is null)
+        {
+            _fileCaches[fileCache.Hash] = entries = [];
+        }
+
+        if (!entries.Exists(u => string.Equals(u.PrefixedFilePath, fileCache.PrefixedFilePath, StringComparison.OrdinalIgnoreCase)))
+        {
+            //_logger.LogTrace("Adding to DB: {hash} => {path}", fileCache.Hash, fileCache.PrefixedFilePath);
+            entries.Add(fileCache);
+        }
+    }
+
+    private FileCacheEntity? CreateFileCacheEntity(FileInfo fileInfo, string prefixedPath, string? hash = null)
+    {
+        hash ??= Crypto.GetFileHash(fileInfo.FullName);
+        var entity = new FileCacheEntity(hash, prefixedPath, fileInfo.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture), fileInfo.Length);
+        entity = ReplacePathPrefixes(entity);
+        AddHashedFile(entity);
+        lock (_fileWriteLock)
+        {
+            File.AppendAllLines(_csvPath, new[] { entity.CsvEntry });
+        }
+        var result = GetFileCacheByPath(fileInfo.FullName);
+        _logger.LogTrace("Creating cache entity for {name} success: {success}", fileInfo.FullName, (result != null));
+        return result;
+    }
+
+    private FileCacheEntity? GetValidatedFileCache(FileCacheEntity fileCache)
+    {
+        var resultingFileCache = ReplacePathPrefixes(fileCache);
+        //_logger.LogTrace("Validating {path}", fileCache.PrefixedFilePath);
+        resultingFileCache = Validate(resultingFileCache);
+        return resultingFileCache;
+    }
+
+    private FileCacheEntity ReplacePathPrefixes(FileCacheEntity fileCache)
+    {
+        if (fileCache.PrefixedFilePath.StartsWith(PenumbraPrefix, StringComparison.OrdinalIgnoreCase))
+        {
+            fileCache.SetResolvedFilePath(fileCache.PrefixedFilePath.Replace(PenumbraPrefix, _ipcManager.Penumbra.ModDirectory, StringComparison.Ordinal));
+        }
+        else if (fileCache.PrefixedFilePath.StartsWith(SubstPrefix, StringComparison.OrdinalIgnoreCase))
+        {
+            fileCache.SetResolvedFilePath(fileCache.PrefixedFilePath.Replace(SubstPrefix, SubstFolder, StringComparison.Ordinal));
+        }
+        else if (fileCache.PrefixedFilePath.StartsWith(CachePrefix, StringComparison.OrdinalIgnoreCase))
+        {
+            fileCache.SetResolvedFilePath(fileCache.PrefixedFilePath.Replace(CachePrefix, _configService.Current.CacheFolder, StringComparison.Ordinal));
+        }
+
+        return fileCache;
+    }
+
+    private FileCacheEntity? Validate(FileCacheEntity fileCache)
+    {
+        var file = new FileInfo(fileCache.ResolvedFilepath);
+        if (!file.Exists)
+        {
+            RemoveHashedFile(fileCache.Hash, fileCache.PrefixedFilePath);
+            return null;
+        }
+
+        if (!string.Equals(file.LastWriteTimeUtc.Ticks.ToString(CultureInfo.InvariantCulture), fileCache.LastModifiedDateTicks, StringComparison.Ordinal))
+        {
+            UpdateHashedFile(fileCache);
+        }
+
+        return fileCache;
+    }
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogInformation("Starting FileCacheManager");
+        lock (_fileWriteLock)
+        {
+            try
+            {
+                _logger.LogInformation("Checking for {bakPath}", CsvBakPath);
+
+                if (File.Exists(CsvBakPath))
+                {
+                    _logger.LogInformation("{bakPath} found, moving to {csvPath}", CsvBakPath, _csvPath);
+
+                    File.Move(CsvBakPath, _csvPath, overwrite: true);
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to move BAK to ORG, deleting BAK");
+                try
+                {
+                    if (File.Exists(CsvBakPath))
+                        File.Delete(CsvBakPath);
+                }
+                catch (Exception ex1)
+                {
+                    _logger.LogWarning(ex1, "Could not delete bak file");
+                }
+            }
+        }
+
+        if (File.Exists(_csvPath))
+        {
+            if (!_ipcManager.Penumbra.APIAvailable || string.IsNullOrEmpty(_ipcManager.Penumbra.ModDirectory))
+            {
+                _mareMediator.Publish(new NotificationMessage("Penumbra not connected",
+                    "Could not load local file cache data. Penumbra is not connected or not properly set up. Please enable and/or configure Penumbra properly to use Elezen. After, reload Elezen in the Plugin installer.",
+                    MareConfiguration.Models.NotificationType.Error));
+            }
+
+            _logger.LogInformation("{csvPath} found, parsing", _csvPath);
+
+            bool success = false;
+            string[] entries = [];
+            int attempts = 0;
+            while (!success && attempts < 10)
+            {
+                try
+                {
+                    _logger.LogInformation("Attempting to read {csvPath}", _csvPath);
+                    entries = File.ReadAllLines(_csvPath);
+                    success = true;
+                }
+                catch (Exception ex)
+                {
+                    attempts++;
+                    _logger.LogWarning(ex, "Could not open {file}, trying again", _csvPath);
+                    Thread.Sleep(100);
+                }
+            }
+
+            if (!entries.Any())
+            {
+                _logger.LogWarning("Could not load entries from {path}, continuing with empty file cache", _csvPath);
+            }
+
+            _logger.LogInformation("Found {amount} files in {path}", entries.Length, _csvPath);
+
+            Dictionary<string, bool> processedFiles = new(StringComparer.OrdinalIgnoreCase);
+            foreach (var entry in entries)
+            {
+                var splittedEntry = entry.Split(CsvSplit, StringSplitOptions.None);
+                try
+                {
+                    var hash = splittedEntry[0];
+                    if (hash.Length != 40) throw new InvalidOperationException("Expected Hash length of 40, received " + hash.Length);
+                    var path = splittedEntry[1];
+                    var time = splittedEntry[2];
+
+                    if (processedFiles.ContainsKey(path))
+                    {
+                        _logger.LogWarning("Already processed {file}, ignoring", path);
+                        continue;
+                    }
+
+                    processedFiles.Add(path, value: true);
+
+                    long size = -1;
+                    long compressed = -1;
+                    if (splittedEntry.Length > 3)
+                    {
+                        if (long.TryParse(splittedEntry[3], CultureInfo.InvariantCulture, out long result))
+                        {
+                            size = result;
+                        }
+                        if (long.TryParse(splittedEntry[4], CultureInfo.InvariantCulture, out long resultCompressed))
+                        {
+                            compressed = resultCompressed;
+                        }
+                    }
+                    AddHashedFile(ReplacePathPrefixes(new FileCacheEntity(hash, path, time, size, compressed)));
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogWarning(ex, "Failed to initialize entry {entry}, ignoring", entry);
+                }
+            }
+
+            if (processedFiles.Count != entries.Length)
+            {
+                WriteOutFullCsv();
+            }
+        }
+
+        _logger.LogInformation("Started FileCacheManager");
+
+        return Task.CompletedTask;
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        WriteOutFullCsv();
+        return Task.CompletedTask;
+    }
+}

MareSynchronos/FileCache/FileCompactor.cs

@@ -0,0 +1,250 @@
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.Services;
+using Microsoft.Extensions.Logging;
+using System.Runtime.InteropServices;
+
+namespace MareSynchronos.FileCache;
+
+public sealed class FileCompactor
+{
+    public const uint FSCTL_DELETE_EXTERNAL_BACKING = 0x90314U;
+    public const ulong WOF_PROVIDER_FILE = 2UL;
+
+    private readonly Dictionary<string, int> _clusterSizes;
+
+    private readonly WOF_FILE_COMPRESSION_INFO_V1 _efInfo;
+    private readonly ILogger<FileCompactor> _logger;
+
+    private readonly MareConfigService _mareConfigService;
+    private readonly DalamudUtilService _dalamudUtilService;
+
+    public FileCompactor(ILogger<FileCompactor> logger, MareConfigService mareConfigService, DalamudUtilService dalamudUtilService)
+    {
+        _clusterSizes = new(StringComparer.Ordinal);
+        _logger = logger;
+        _mareConfigService = mareConfigService;
+        _dalamudUtilService = dalamudUtilService;
+        _efInfo = new WOF_FILE_COMPRESSION_INFO_V1
+        {
+            Algorithm = CompressionAlgorithm.XPRESS8K,
+            Flags = 0
+        };
+    }
+
+    private enum CompressionAlgorithm
+    {
+        NO_COMPRESSION = -2,
+        LZNT1 = -1,
+        XPRESS4K = 0,
+        LZX = 1,
+        XPRESS8K = 2,
+        XPRESS16K = 3
+    }
+
+    public bool MassCompactRunning { get; private set; } = false;
+
+    public string Progress { get; private set; } = string.Empty;
+
+    public void CompactStorage(bool compress)
+    {
+        MassCompactRunning = true;
+
+        int currentFile = 1;
+        var allFiles = Directory.EnumerateFiles(_mareConfigService.Current.CacheFolder).ToList();
+        int allFilesCount = allFiles.Count;
+        foreach (var file in allFiles)
+        {
+            Progress = $"{currentFile}/{allFilesCount}";
+            if (compress)
+                CompactFile(file);
+            else
+                DecompressFile(file);
+            currentFile++;
+        }
+
+        MassCompactRunning = false;
+    }
+
+    public long GetFileSizeOnDisk(FileInfo fileInfo, bool? isNTFS = null)
+    {
+        bool ntfs = isNTFS ?? string.Equals(new DriveInfo(fileInfo.Directory!.Root.FullName).DriveFormat, "NTFS", StringComparison.OrdinalIgnoreCase);
+
+        if (_dalamudUtilService.IsWine || !ntfs) return fileInfo.Length;
+
+        var clusterSize = GetClusterSize(fileInfo);
+        if (clusterSize == -1) return fileInfo.Length;
+        var losize = GetCompressedFileSizeW(fileInfo.FullName, out uint hosize);
+        var size = (long)hosize << 32 | losize;
+        return ((size + clusterSize - 1) / clusterSize) * clusterSize;
+    }
+
+    public async Task WriteAllBytesAsync(string filePath, byte[] decompressedFile, CancellationToken token)
+    {
+        await File.WriteAllBytesAsync(filePath, decompressedFile, token).ConfigureAwait(false);
+
+        if (_dalamudUtilService.IsWine || !_mareConfigService.Current.UseCompactor)
+        {
+            return;
+        }
+
+        CompactFile(filePath);
+    }
+
+    public void RenameAndCompact(string filePath, string originalFilePath)
+    {
+        try
+        {
+            File.Move(originalFilePath, filePath);
+        }
+        catch (IOException)
+        {
+            // File already exists
+            return;
+        }
+
+        if (_dalamudUtilService.IsWine || !_mareConfigService.Current.UseCompactor)
+        {
+            return;
+        }
+
+        CompactFile(filePath);
+    }
+
+    [DllImport("kernel32.dll")]
+    private static extern int DeviceIoControl(IntPtr hDevice, uint dwIoControlCode, IntPtr lpInBuffer, uint nInBufferSize, IntPtr lpOutBuffer, uint nOutBufferSize, out IntPtr lpBytesReturned, out IntPtr lpOverlapped);
+
+    [DllImport("kernel32.dll")]
+    private static extern uint GetCompressedFileSizeW([In, MarshalAs(UnmanagedType.LPWStr)] string lpFileName,
+                                              [Out, MarshalAs(UnmanagedType.U4)] out uint lpFileSizeHigh);
+
+    [DllImport("kernel32.dll", SetLastError = true, PreserveSig = true)]
+    private static extern int GetDiskFreeSpaceW([In, MarshalAs(UnmanagedType.LPWStr)] string lpRootPathName,
+           out uint lpSectorsPerCluster, out uint lpBytesPerSector, out uint lpNumberOfFreeClusters,
+           out uint lpTotalNumberOfClusters);
+
+    [DllImport("WoFUtil.dll")]
+    private static extern int WofIsExternalFile([MarshalAs(UnmanagedType.LPWStr)] string Filepath, out int IsExternalFile, out uint Provider, out WOF_FILE_COMPRESSION_INFO_V1 Info, ref uint BufferLength);
+
+    [DllImport("WofUtil.dll")]
+    private static extern int WofSetFileDataLocation(IntPtr FileHandle, ulong Provider, IntPtr ExternalFileInfo, ulong Length);
+
+    private void CompactFile(string filePath)
+    {
+        var fs = new DriveInfo(new FileInfo(filePath).Directory!.Root.FullName);
+        bool isNTFS = string.Equals(fs.DriveFormat, "NTFS", StringComparison.OrdinalIgnoreCase);
+        if (!isNTFS)
+        {
+            _logger.LogWarning("Drive for file {file} is not NTFS", filePath);
+            return;
+        }
+
+        var fi = new FileInfo(filePath);
+        var oldSize = fi.Length;
+        var clusterSize = GetClusterSize(fi);
+
+        if (oldSize < Math.Max(clusterSize, 8 * 1024))
+        {
+            _logger.LogDebug("File {file} is smaller than cluster size ({size}), ignoring", filePath, clusterSize);
+            return;
+        }
+
+        if (!IsCompactedFile(filePath))
+        {
+            _logger.LogDebug("Compacting file to XPRESS8K: {file}", filePath);
+
+            WOFCompressFile(filePath);
+
+            var newSize = GetFileSizeOnDisk(fi);
+
+            _logger.LogDebug("Compressed {file} from {orig}b to {comp}b", filePath, oldSize, newSize);
+        }
+        else
+        {
+            _logger.LogDebug("File {file} already compressed", filePath);
+        }
+    }
+
+    private void DecompressFile(string path)
+    {
+        _logger.LogDebug("Removing compression from {file}", path);
+        try
+        {
+            using (var fs = new FileStream(path, FileMode.Open))
+            {
+#pragma warning disable S3869 // "SafeHandle.DangerousGetHandle" should not be called
+                var hDevice = fs.SafeFileHandle.DangerousGetHandle();
+#pragma warning restore S3869 // "SafeHandle.DangerousGetHandle" should not be called
+                _ = DeviceIoControl(hDevice, FSCTL_DELETE_EXTERNAL_BACKING, nint.Zero, 0, nint.Zero, 0, out _, out _);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error decompressing file {path}", path);
+        }
+    }
+
+    private int GetClusterSize(FileInfo fi)
+    {
+        if (!fi.Exists) return -1;
+        var root = fi.Directory?.Root.FullName.ToLower() ?? string.Empty;
+        if (string.IsNullOrEmpty(root)) return -1;
+        if (_clusterSizes.TryGetValue(root, out int value)) return value;
+        _logger.LogDebug("Getting Cluster Size for {path}, root {root}", fi.FullName, root);
+        int result = GetDiskFreeSpaceW(root, out uint sectorsPerCluster, out uint bytesPerSector, out _, out _);
+        if (result == 0) return -1;
+        _clusterSizes[root] = (int)(sectorsPerCluster * bytesPerSector);
+        _logger.LogDebug("Determined Cluster Size for root {root}: {cluster}", root, _clusterSizes[root]);
+        return _clusterSizes[root];
+    }
+
+    private static bool IsCompactedFile(string filePath)
+    {
+        uint buf = 8;
+        _ = WofIsExternalFile(filePath, out int isExtFile, out uint _, out var info, ref buf);
+        if (isExtFile == 0) return false;
+        return info.Algorithm == CompressionAlgorithm.XPRESS8K;
+    }
+
+    private void WOFCompressFile(string path)
+    {
+        var efInfoPtr = Marshal.AllocHGlobal(Marshal.SizeOf(_efInfo));
+        Marshal.StructureToPtr(_efInfo, efInfoPtr, fDeleteOld: true);
+        ulong length = (ulong)Marshal.SizeOf(_efInfo);
+        try
+        {
+            using (var fs = new FileStream(path, FileMode.Open))
+            {
+#pragma warning disable S3869 // "SafeHandle.DangerousGetHandle" should not be called
+                var hFile = fs.SafeFileHandle.DangerousGetHandle();
+#pragma warning restore S3869 // "SafeHandle.DangerousGetHandle" should not be called
+                if (fs.SafeFileHandle.IsInvalid)
+                {
+                    _logger.LogWarning("Invalid file handle to {file}", path);
+                }
+                else
+                {
+                    var ret = WofSetFileDataLocation(hFile, WOF_PROVIDER_FILE, efInfoPtr, length);
+                    if (!(ret == 0 || ret == unchecked((int)0x80070158)))
+                    {
+                        _logger.LogWarning("Failed to compact {file}: {ret}", path, ret.ToString("X"));
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error compacting file {path}", path);
+        }
+        finally
+        {
+            Marshal.FreeHGlobal(efInfoPtr);
+        }
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    private struct WOF_FILE_COMPRESSION_INFO_V1
+    {
+        public CompressionAlgorithm Algorithm;
+        public ulong Flags;
+    }
+}

MareSynchronos/FileCache/FileState.cs

@@ -0,0 +1,8 @@
+namespace MareSynchronos.FileCache;
+
+public enum FileState
+{
+    Valid,
+    RequireUpdate,
+    RequireDeletion,
+}

MareSynchronos/FileCache/TransientResourceManager.cs

@@ -0,0 +1,313 @@
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Data;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+
+namespace MareSynchronos.FileCache;
+
+public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
+{
+    private readonly Lock _cacheAdditionLock = new();
+    private readonly HashSet<string> _cachedHandledPaths = new(StringComparer.Ordinal);
+    private readonly TransientConfigService _configurationService;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly string[] _fileTypesToHandle = ["tmb", "pap", "avfx", "atex", "sklb", "eid", "phyb", "scd", "skp", "shpk"];
+    private readonly HashSet<GameObjectHandler> _playerRelatedPointers = [];
+    private ConcurrentDictionary<IntPtr, ObjectKind> _cachedFrameAddresses = [];
+
+    public TransientResourceManager(ILogger<TransientResourceManager> logger, TransientConfigService configurationService,
+        DalamudUtilService dalamudUtil, MareMediator mediator) : base(logger, mediator)
+    {
+        _configurationService = configurationService;
+        _dalamudUtil = dalamudUtil;
+
+        Mediator.Subscribe<PenumbraResourceLoadMessage>(this, Manager_PenumbraResourceLoadEvent);
+        Mediator.Subscribe<PenumbraModSettingChangedMessage>(this, (_) => Manager_PenumbraModSettingChanged());
+        Mediator.Subscribe<PriorityFrameworkUpdateMessage>(this, (_) => DalamudUtil_FrameworkUpdate());
+        Mediator.Subscribe<ClassJobChangedMessage>(this, (msg) =>
+        {
+            if (_playerRelatedPointers.Contains(msg.GameObjectHandler))
+            {
+                DalamudUtil_ClassJobChanged();
+            }
+        });
+        Mediator.Subscribe<GameObjectHandlerCreatedMessage>(this, (msg) =>
+        {
+            if (!msg.OwnedObject) return;
+            _playerRelatedPointers.Add(msg.GameObjectHandler);
+        });
+        Mediator.Subscribe<GameObjectHandlerDestroyedMessage>(this, (msg) =>
+        {
+            if (!msg.OwnedObject) return;
+            _playerRelatedPointers.Remove(msg.GameObjectHandler);
+        });
+    }
+
+    private string PlayerPersistentDataKey => _dalamudUtil.GetPlayerNameAsync().GetAwaiter().GetResult() + "_" + _dalamudUtil.GetHomeWorldIdAsync().GetAwaiter().GetResult();
+    private ConcurrentDictionary<ObjectKind, HashSet<string>>? _semiTransientResources = null;
+    private ConcurrentDictionary<ObjectKind, HashSet<string>> SemiTransientResources
+    {
+        get
+        {
+            if (_semiTransientResources == null)
+            {
+                _semiTransientResources = new();
+                _semiTransientResources.TryAdd(ObjectKind.Player, new HashSet<string>(StringComparer.Ordinal));
+                if (_configurationService.Current.PlayerPersistentTransientCache.TryGetValue(PlayerPersistentDataKey, out var gamePaths))
+                {
+                    int restored = 0;
+                    foreach (var gamePath in gamePaths)
+                    {
+                        if (string.IsNullOrEmpty(gamePath)) continue;
+
+                        try
+                        {
+                            Logger.LogDebug("Loaded persistent transient resource {path}", gamePath);
+                            SemiTransientResources[ObjectKind.Player].Add(gamePath);
+                            restored++;
+                        }
+                        catch (Exception ex)
+                        {
+                            Logger.LogWarning(ex, "Error during loading persistent transient resource {path}", gamePath);
+                        }
+                    }
+                    Logger.LogDebug("Restored {restored}/{total} semi persistent resources", restored, gamePaths.Count);
+                }
+            }
+
+            return _semiTransientResources;
+        }
+    }
+    private ConcurrentDictionary<IntPtr, HashSet<string>> TransientResources { get; } = new();
+
+    public void CleanUpSemiTransientResources(ObjectKind objectKind, List<FileReplacement>? fileReplacement = null)
+    {
+        if (SemiTransientResources.TryGetValue(objectKind, out HashSet<string>? value))
+        {
+            if (fileReplacement == null)
+            {
+                value.Clear();
+                return;
+            }
+
+            foreach (var replacement in fileReplacement.Where(p => !p.HasFileReplacement).SelectMany(p => p.GamePaths).ToList())
+            {
+                value.RemoveWhere(p => string.Equals(p, replacement, StringComparison.OrdinalIgnoreCase));
+            }
+        }
+    }
+
+    public HashSet<string> GetSemiTransientResources(ObjectKind objectKind)
+    {
+        if (SemiTransientResources.TryGetValue(objectKind, out var result))
+        {
+            return result ?? new HashSet<string>(StringComparer.Ordinal);
+        }
+
+        return new HashSet<string>(StringComparer.Ordinal);
+    }
+
+    public List<string> GetTransientResources(IntPtr gameObject)
+    {
+        if (TransientResources.TryGetValue(gameObject, out var result))
+        {
+            return [.. result];
+        }
+
+        return [];
+    }
+
+    public void PersistTransientResources(IntPtr gameObject, ObjectKind objectKind)
+    {
+        if (!SemiTransientResources.TryGetValue(objectKind, out HashSet<string>? value))
+        {
+            value = new HashSet<string>(StringComparer.Ordinal);
+            SemiTransientResources[objectKind] = value;
+        }
+
+        if (!TransientResources.TryGetValue(gameObject, out var resources))
+        {
+            return;
+        }
+
+        var transientResources = resources.ToList();
+        Logger.LogDebug("Persisting {count} transient resources", transientResources.Count);
+        foreach (var gamePath in transientResources)
+        {
+            value.Add(gamePath);
+        }
+
+        if (objectKind == ObjectKind.Player && SemiTransientResources.TryGetValue(ObjectKind.Player, out var fileReplacements))
+        {
+            _configurationService.Current.PlayerPersistentTransientCache[PlayerPersistentDataKey] = fileReplacements.Where(f => !string.IsNullOrEmpty(f)).ToHashSet(StringComparer.Ordinal);
+            _configurationService.Save();
+        }
+        TransientResources[gameObject].Clear();
+    }
+
+    internal void AddSemiTransientResource(ObjectKind objectKind, string item)
+    {
+        if (!SemiTransientResources.TryGetValue(objectKind, out HashSet<string>? value))
+        {
+            value = new HashSet<string>(StringComparer.Ordinal);
+            SemiTransientResources[objectKind] = value;
+        }
+
+        value.Add(item.ToLowerInvariant());
+    }
+
+    internal void ClearTransientPaths(IntPtr ptr, List<string> list)
+    {
+        if (TransientResources.TryGetValue(ptr, out var set))
+        {
+            foreach (var file in set.Where(p => list.Contains(p, StringComparer.OrdinalIgnoreCase)))
+            {
+                Logger.LogTrace("Removing From Transient: {file}", file);
+            }
+
+            int removed = set.RemoveWhere(p => list.Contains(p, StringComparer.OrdinalIgnoreCase));
+            Logger.LogInformation("Removed {removed} previously existing transient paths", removed);
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        try
+        {
+            TransientResources.Clear();
+            SemiTransientResources.Clear();
+            if (SemiTransientResources.TryGetValue(ObjectKind.Player, out HashSet<string>? value))
+            {
+                _configurationService.Current.PlayerPersistentTransientCache[PlayerPersistentDataKey] = value;
+                _configurationService.Save();
+            }
+        }
+        catch { }
+    }
+
+    private void DalamudUtil_ClassJobChanged()
+    {
+        if (SemiTransientResources.TryGetValue(ObjectKind.Pet, out HashSet<string>? value))
+        {
+            value?.Clear();
+        }
+    }
+
+    private void DalamudUtil_FrameworkUpdate()
+    {
+        _cachedFrameAddresses = _cachedFrameAddresses = new ConcurrentDictionary<nint, ObjectKind>(_playerRelatedPointers.Where(k => k.Address != nint.Zero).ToDictionary(c => c.CurrentAddress(), c => c.ObjectKind));
+        lock (_cacheAdditionLock)
+        {
+            _cachedHandledPaths.Clear();
+        }
+        foreach (var item in TransientResources.Where(item => !_dalamudUtil.IsGameObjectPresent(item.Key)).Select(i => i.Key).ToList())
+        {
+            Logger.LogDebug("Object not present anymore: {addr}", item.ToString("X"));
+            TransientResources.TryRemove(item, out _);
+        }
+    }
+
+    private void Manager_PenumbraModSettingChanged()
+    {
+        _ = Task.Run(() =>
+        {
+            Logger.LogDebug("Penumbra Mod Settings changed, verifying SemiTransientResources");
+            foreach (var item in _playerRelatedPointers)
+            {
+                Mediator.Publish(new TransientResourceChangedMessage(item.Address));
+            }
+        });
+    }
+
+    private void Manager_PenumbraResourceLoadEvent(PenumbraResourceLoadMessage msg)
+    {
+        var gamePath = msg.GamePath.ToLowerInvariant();
+        var gameObject = msg.GameObject;
+        var filePath = msg.FilePath;
+
+        // ignore files already processed this frame
+        if (_cachedHandledPaths.Contains(gamePath)) return;
+
+        lock (_cacheAdditionLock)
+        {
+            _cachedHandledPaths.Add(gamePath);
+        }
+
+        // replace individual mtrl stuff
+        if (filePath.StartsWith("|", StringComparison.OrdinalIgnoreCase))
+        {
+            filePath = filePath.Split("|")[2];
+        }
+        // replace filepath
+        filePath = filePath.ToLowerInvariant().Replace("\\", "/", StringComparison.OrdinalIgnoreCase);
+
+        // ignore files that are the same
+        var replacedGamePath = gamePath.ToLowerInvariant().Replace("\\", "/", StringComparison.OrdinalIgnoreCase);
+        if (string.Equals(filePath, replacedGamePath, StringComparison.OrdinalIgnoreCase)) return;
+
+        // ignore files to not handle
+        if (!_fileTypesToHandle.Any(type => gamePath.EndsWith(type, StringComparison.OrdinalIgnoreCase)))
+        {
+            lock (_cacheAdditionLock)
+            {
+                _cachedHandledPaths.Add(gamePath);
+            }
+            return;
+        }
+
+        // ignore files not belonging to anything player related
+        if (!_cachedFrameAddresses.TryGetValue(gameObject, out var objectKind))
+        {
+            lock (_cacheAdditionLock)
+            {
+                _cachedHandledPaths.Add(gamePath);
+            }
+            return;
+        }
+
+        if (!TransientResources.TryGetValue(gameObject, out HashSet<string>? value))
+        {
+            value = new(StringComparer.OrdinalIgnoreCase);
+            TransientResources[gameObject] = value;
+        }
+
+        if (value.Contains(replacedGamePath) ||
+            SemiTransientResources.SelectMany(k => k.Value).Any(f => string.Equals(f, gamePath, StringComparison.OrdinalIgnoreCase)))
+        {
+            Logger.LogTrace("Not adding {replacedPath} : {filePath}", replacedGamePath, filePath);
+        }
+        else
+        {
+            var thing = _playerRelatedPointers.FirstOrDefault(f => f.Address == gameObject);
+            value.Add(replacedGamePath);
+            Logger.LogDebug("Adding {replacedGamePath} for {gameObject} ({filePath})", replacedGamePath, thing?.ToString() ?? gameObject.ToString("X"), filePath);
+            _ = Task.Run(async () =>
+            {
+                _sendTransientCts?.Cancel();
+                _sendTransientCts?.Dispose();
+                _sendTransientCts = new();
+                var token = _sendTransientCts.Token;
+                await Task.Delay(TimeSpan.FromSeconds(2), token).ConfigureAwait(false);
+                Mediator.Publish(new TransientResourceChangedMessage(gameObject));
+            });
+        }
+    }
+
+    internal void RemoveTransientResource(ObjectKind objectKind, string path)
+    {
+        if (SemiTransientResources.TryGetValue(objectKind, out var resources))
+        {
+            resources.RemoveWhere(f => string.Equals(path, f, StringComparison.OrdinalIgnoreCase));
+            _configurationService.Current.PlayerPersistentTransientCache[PlayerPersistentDataKey] = resources;
+            _configurationService.Save();
+        }
+    }
+
+    private CancellationTokenSource _sendTransientCts = new();
+}

MareSynchronos/GlobalSuppressions.cs

@@ -0,0 +1,8 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Interoperability", "CA1416:Validate platform compatibility", Justification = "<Pending>", Scope = "member", Target = "~M:MareSynchronos.Services.CharaDataManager.AttachPoseData(MareSynchronos.API.Dto.CharaData.PoseEntry,MareSynchronos.Services.CharaData.Models.CharaDataExtendedUpdateDto)")]

MareSynchronos/Interop/BlockedCharacterHandler.cs

@@ -0,0 +1,42 @@
+using Dalamud.Plugin.Services;
+using FFXIVClientStructs.FFXIV.Client.Game.Character;
+using FFXIVClientStructs.FFXIV.Client.UI.Info;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop;
+
+public unsafe class BlockedCharacterHandler
+{
+    private sealed record CharaData(ulong AccId, ulong ContentId);
+    private readonly Dictionary<CharaData, bool> _blockedCharacterCache = new();
+
+    private readonly ILogger<BlockedCharacterHandler> _logger;
+
+    public BlockedCharacterHandler(ILogger<BlockedCharacterHandler> logger, IGameInteropProvider gameInteropProvider)
+    {
+        gameInteropProvider.InitializeFromAttributes(this);
+        _logger = logger;
+    }
+
+    private static CharaData GetIdsFromPlayerPointer(nint ptr)
+    {
+        if (ptr == nint.Zero) return new(0, 0);
+        var castChar = ((BattleChara*)ptr);
+        return new(castChar->Character.AccountId, castChar->Character.ContentId);
+    }
+
+    public bool IsCharacterBlocked(nint ptr, out bool firstTime)
+    {
+        firstTime = false;
+        var combined = GetIdsFromPlayerPointer(ptr);
+        if (_blockedCharacterCache.TryGetValue(combined, out var isBlocked))
+            return isBlocked;
+
+        firstTime = true;
+        var blockStatus = InfoProxyBlacklist.Instance()->GetBlockResultType(combined.AccId, combined.ContentId);
+        _logger.LogTrace("CharaPtr {ptr} is BlockStatus: {status}", ptr, blockStatus);
+        if ((int)blockStatus == 0)
+            return false;
+        return _blockedCharacterCache[combined] = blockStatus != InfoProxyBlacklist.BlockResultType.NotBlocked;
+    }
+}

MareSynchronos/Interop/DalamudLogger.cs

@@ -0,0 +1,55 @@
+using Dalamud.Plugin.Services;
+using MareSynchronos.MareConfiguration;
+using Microsoft.Extensions.Logging;
+using System.Text;
+
+namespace MareSynchronos.Interop;
+
+internal sealed class DalamudLogger : ILogger
+{
+    private readonly MareConfigService _mareConfigService;
+    private readonly string _name;
+    private readonly IPluginLog _pluginLog;
+
+    public DalamudLogger(string name, MareConfigService mareConfigService, IPluginLog pluginLog)
+    {
+        _name = name;
+        _mareConfigService = mareConfigService;
+        _pluginLog = pluginLog;
+    }
+
+    public IDisposable BeginScope<TState>(TState state) where TState : notnull => default!;
+
+    public bool IsEnabled(LogLevel logLevel)
+    {
+        return (int)_mareConfigService.Current.LogLevel <= (int)logLevel;
+    }
+
+    public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)
+    {
+        if (!IsEnabled(logLevel)) return;
+
+        if ((int)logLevel <= (int)LogLevel.Information)
+            _pluginLog.Information($"[{_name}]{{{(int)logLevel}}} {state}");
+        else
+        {
+            StringBuilder sb = new();
+            sb.Append($"[{_name}]{{{(int)logLevel}}} {state}: {exception?.Message}");
+            if (!string.IsNullOrWhiteSpace(exception?.StackTrace))
+                sb.AppendLine(exception?.StackTrace);
+            var innerException = exception?.InnerException;
+            while (innerException != null)
+            {
+                sb.AppendLine($"InnerException {innerException}: {innerException.Message}");
+                sb.AppendLine(innerException.StackTrace);
+                innerException = innerException.InnerException;
+            }
+            if (logLevel == LogLevel.Warning)
+                _pluginLog.Warning(sb.ToString());
+            else if (logLevel == LogLevel.Error)
+                _pluginLog.Error(sb.ToString());
+            else
+                _pluginLog.Fatal(sb.ToString());
+        }
+    }
+}

MareSynchronos/Interop/DalamudLoggingProvider.cs

@@ -0,0 +1,44 @@
+using Dalamud.Plugin.Services;
+using MareSynchronos.MareConfiguration;
+using Microsoft.Extensions.Logging;
+
+using System.Collections.Concurrent;
+
+namespace MareSynchronos.Interop;
+
+[ProviderAlias("Dalamud")]
+public sealed class DalamudLoggingProvider : ILoggerProvider
+{
+    private readonly ConcurrentDictionary<string, DalamudLogger> _loggers =
+        new(StringComparer.OrdinalIgnoreCase);
+
+    private readonly MareConfigService _mareConfigService;
+    private readonly IPluginLog _pluginLog;
+
+    public DalamudLoggingProvider(MareConfigService mareConfigService, IPluginLog pluginLog)
+    {
+        _mareConfigService = mareConfigService;
+        _pluginLog = pluginLog;
+    }
+
+    public ILogger CreateLogger(string categoryName)
+    {
+        string catName = categoryName.Split(".", StringSplitOptions.RemoveEmptyEntries).Last();
+        if (catName.Length > 15)
+        {
+            catName = string.Join("", catName.Take(6)) + "..." + string.Join("", catName.TakeLast(6));
+        }
+        else
+        {
+            catName = string.Join("", Enumerable.Range(0, 15 - catName.Length).Select(_ => " ")) + catName;
+        }
+
+        return _loggers.GetOrAdd(catName, name => new DalamudLogger(name, _mareConfigService, _pluginLog));
+    }
+
+    public void Dispose()
+    {
+        _loggers.Clear();
+        GC.SuppressFinalize(this);
+    }
+}

MareSynchronos/Interop/DalamudLoggingProviderExtensions.cs

@@ -0,0 +1,20 @@
+using Dalamud.Plugin.Services;
+using MareSynchronos.MareConfiguration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop;
+
+public static class DalamudLoggingProviderExtensions
+{
+    public static ILoggingBuilder AddDalamudLogging(this ILoggingBuilder builder, IPluginLog pluginLog)
+    {
+        builder.ClearProviders();
+
+        builder.Services.TryAddEnumerable(ServiceDescriptor.Singleton<ILoggerProvider, DalamudLoggingProvider>
+            (b => new DalamudLoggingProvider(b.GetRequiredService<MareConfigService>(), pluginLog)));
+
+        return builder;
+    }
+}

MareSynchronos/Interop/GameChatHooks.cs

@@ -0,0 +1,333 @@
+using Dalamud.Game.Text.SeStringHandling;
+using Dalamud.Game.Text.SeStringHandling.Payloads;
+using Dalamud.Hooking;
+using Dalamud.Memory;
+using Dalamud.Plugin.Services;
+using Dalamud.Utility.Signatures;
+using FFXIVClientStructs.FFXIV.Client.System.String;
+using FFXIVClientStructs.FFXIV.Client.UI;
+using FFXIVClientStructs.FFXIV.Client.UI.Agent;
+using FFXIVClientStructs.FFXIV.Client.UI.Misc;
+using FFXIVClientStructs.FFXIV.Client.UI.Shell;
+using FFXIVClientStructs.FFXIV.Component.Shell;
+using MareSynchronos.Services;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop;
+
+public record ChatChannelOverride
+{
+    public string ChannelName = string.Empty;
+    public Action<byte[]>? ChatMessageHandler;
+}
+
+public unsafe sealed class GameChatHooks : IDisposable
+{
+    // Based on https://git.anna.lgbt/anna/ExtraChat/src/branch/main/client/ExtraChat/GameFunctions.cs
+
+    private readonly ILogger<GameChatHooks> _logger;
+    private readonly Action<int, byte[]> _ssCommandHandler;
+
+    #region signatures
+    #pragma warning disable CS0649
+    // I do not know what kind of black magic this function performs
+    // Client::UI::Misc::PronounModule::???
+    [Signature("E8 ?? ?? ?? ?? 44 88 74 24 ?? 4C 8D 45")]
+    private readonly delegate* unmanaged<PronounModule*, Utf8String*, byte, Utf8String*> _processStringStep2;
+
+    // Component::Shell::ShellCommandModule::ExecuteCommandInner
+    private delegate void SendMessageDelegate(ShellCommandModule* module, Utf8String* message, UIModule* uiModule);
+    [Signature(
+        "E8 ?? ?? ?? ?? FE 87 ?? ?? ?? ?? C7 87",
+        DetourName = nameof(SendMessageDetour)
+    )]
+    private Hook<SendMessageDelegate>? SendMessageHook { get; init; }
+
+    // Client::UI::Shell::RaptureShellModule::SetChatChannel
+    private delegate void SetChatChannelDelegate(RaptureShellModule* module, uint channel);
+    [Signature(
+        "E8 ?? ?? ?? ?? 33 C0 EB ?? 85 D2",
+        DetourName = nameof(SetChatChannelDetour)
+    )]
+    private Hook<SetChatChannelDelegate>? SetChatChannelHook { get; init; }
+
+    // Component::Shell::ShellCommandModule::ChangeChannelName
+    private delegate byte* ChangeChannelNameDelegate(AgentChatLog* agent);
+    [Signature(
+        "E8 ?? ?? ?? ?? BA ?? ?? ?? ?? 48 8D 4D B0 48 8B F8 E8 ?? ?? ?? ?? 41 8B D6",
+        DetourName = nameof(ChangeChannelNameDetour)
+    )]
+    private Hook<ChangeChannelNameDelegate>? ChangeChannelNameHook { get; init; }
+
+    // Client::UI::Agent::AgentChatLog::???
+    private delegate byte ShouldDoNameLookupDelegate(AgentChatLog* agent);
+    [Signature(
+        "48 89 5C 24 ?? 57 48 83 EC ?? 48 8B D9 40 32 FF 48 8B 49 ?? ?? ?? ?? FF 50",
+        DetourName = nameof(ShouldDoNameLookupDetour)
+    )]
+    private Hook<ShouldDoNameLookupDelegate>? ShouldDoNameLookupHook { get; init; }
+
+    // Temporary chat channel change (via hotkey)
+    // Client::UI::Shell::RaptureShellModule::???
+    private delegate ulong TempChatChannelDelegate(RaptureShellModule* module, uint x, uint y, ulong z);
+    [Signature(
+        "48 89 5C 24 ?? 48 89 6C 24 ?? 48 89 74 24 ?? 57 48 83 EC ?? 83 B9 ?? ?? ?? ?? ?? 49 8B F9 41 8B F0",
+        DetourName = nameof(TempChatChannelDetour)
+    )]
+    private Hook<TempChatChannelDelegate>? TempChatChannelHook { get; init; }
+
+    // Temporary tell target change (via hotkey)
+    // Client::UI::Shell::RaptureShellModule::SetContextTellTargetInForay
+    private delegate ulong TempTellTargetDelegate(RaptureShellModule* module, ulong a, ulong b, ulong c, ushort d, ulong e, ulong f, ushort g);
+    [Signature(
+        "48 89 5C 24 ?? 48 89 6C 24 ?? 48 89 74 24 ?? 57 48 83 EC ?? 83 B9 ?? ?? ?? ?? ?? 41 0F B7 F9",
+        DetourName = nameof(TempTellTargetDetour)
+    )]
+    private Hook<TempTellTargetDelegate>? TempTellTargetHook { get; init; }
+
+    // Called every frame while the chat bar is not focused
+    private delegate void UnfocusTickDelegate(RaptureShellModule* module);
+    [Signature(
+        "40 53 48 83 EC ?? 83 B9 ?? ?? ?? ?? ?? 48 8B D9 0F 84 ?? ?? ?? ?? 48 8D 91",
+        DetourName = nameof(UnfocusTickDetour)
+    )]
+    private Hook<UnfocusTickDelegate>? UnfocusTickHook { get; init; }
+    #pragma warning restore CS0649
+    #endregion
+
+    private ChatChannelOverride? _chatChannelOverride;
+    private ChatChannelOverride? _chatChannelOverrideTempBuffer;
+    private bool _shouldForceNameLookup = false;
+
+    private DateTime _nextMessageIsReply = DateTime.UnixEpoch;
+
+    public ChatChannelOverride? ChatChannelOverride
+    {
+        get => _chatChannelOverride;
+        set {
+            _chatChannelOverride = value;
+            _shouldForceNameLookup = true;
+        }
+    }
+
+    private void StashChatChannel()
+    {
+        if (_chatChannelOverride != null)
+        {
+            _logger.LogTrace("Stashing chat channel");
+            _chatChannelOverrideTempBuffer = _chatChannelOverride;
+            ChatChannelOverride = null;
+        }
+    }
+
+    private void UnstashChatChannel()
+    {
+        if (_chatChannelOverrideTempBuffer != null)
+        {
+            _logger.LogTrace("Unstashing chat channel");
+            ChatChannelOverride = _chatChannelOverrideTempBuffer;
+            _chatChannelOverrideTempBuffer = null;
+        }
+    }
+
+    public GameChatHooks(ILogger<GameChatHooks> logger, IGameInteropProvider gameInteropProvider, Action<int, byte[]> ssCommandHandler)
+    {
+        _logger = logger;
+        _ssCommandHandler = ssCommandHandler;
+
+        logger.LogInformation("Initializing GameChatHooks");
+        gameInteropProvider.InitializeFromAttributes(this);
+
+        SendMessageHook?.Enable();
+        SetChatChannelHook?.Enable();
+        ChangeChannelNameHook?.Enable();
+        ShouldDoNameLookupHook?.Enable();
+        TempChatChannelHook?.Enable();
+        TempTellTargetHook?.Enable();
+        UnfocusTickHook?.Enable();
+    }
+
+    public void Dispose()
+    {
+        SendMessageHook?.Dispose();
+        SetChatChannelHook?.Dispose();
+        ChangeChannelNameHook?.Dispose();
+        ShouldDoNameLookupHook?.Dispose();
+        TempChatChannelHook?.Dispose();
+        TempTellTargetHook?.Dispose();
+        UnfocusTickHook?.Dispose();
+    }
+
+    private byte[] ProcessChatMessage(Utf8String* message)
+    {
+        var pronounModule = UIModule.Instance()->GetPronounModule();
+        var chatString1 = pronounModule->ProcessString(message, true);
+        var chatString2 = _processStringStep2(pronounModule, chatString1, 1);
+        return MemoryHelper.ReadRaw((nint)chatString2->StringPtr.Value, chatString2->Length);
+    }
+
+    private void SendMessageDetour(ShellCommandModule* thisPtr, Utf8String* message, UIModule* uiModule)
+    {
+        try
+        {
+            var messageLength = message->Length;
+            var messageSpan = message->AsSpan();
+
+            bool isCommand = false;
+            bool isReply = false;
+
+            var utcNow = DateTime.UtcNow;
+
+            // Check if chat input begins with a command (or auto-translated command)
+            // Or if we think we're being called to send text via the /r command
+            if (_nextMessageIsReply >= utcNow)
+            {
+                isCommand = true;
+            }
+            else if (messageLength == 0 || messageSpan[0] == (byte)'/' || !messageSpan.ContainsAnyExcept((byte)' '))
+            {
+                isCommand = true;
+                if (messageSpan.StartsWith(System.Text.Encoding.ASCII.GetBytes("/r ")) || messageSpan.StartsWith(System.Text.Encoding.ASCII.GetBytes("/reply ")))
+                    isReply = true;
+            }
+            else if (messageSpan[0] == (byte)0x02) /* Payload.START_BYTE */
+            {
+                var payload = Payload.Decode(new BinaryReader(new UnmanagedMemoryStream(message->StringPtr, message->BufSize))) as AutoTranslatePayload;
+
+                // Auto-translate text begins with /
+                if (payload != null && payload.Text.Length > 2 && payload.Text[2] == '/')
+                {
+                    isCommand = true;
+                    if (payload.Text[2..].StartsWith("/r ", StringComparison.Ordinal) || payload.Text[2..].StartsWith("/reply ", StringComparison.Ordinal))
+                        isReply = true;
+                }
+            }
+
+            // When using /r the game will set a flag and then call this function a second time
+            // The next call to this function will be raw text intended for the IM recipient
+            // This flag's validity is time-limited as a fail-safe
+            if (isReply)
+                _nextMessageIsReply = utcNow + TimeSpan.FromMilliseconds(100);
+
+            // If it is a command, check if it begins with /ss first so we can handle the message directly
+            // Letting Dalamud handle the commands causes all of the special payloads to be dropped
+            if (isCommand && messageSpan.StartsWith(System.Text.Encoding.ASCII.GetBytes("/ss")))
+            {
+                for (int i = 1; i <= ChatService.CommandMaxNumber; ++i)
+                {
+                    var cmdString = $"/ss{i} ";
+                    if (messageSpan.StartsWith(System.Text.Encoding.ASCII.GetBytes(cmdString)))
+                    {
+                        var ssChatBytes = ProcessChatMessage(message);
+                        ssChatBytes = ssChatBytes.Skip(cmdString.Length).ToArray();
+                        _ssCommandHandler?.Invoke(i, ssChatBytes);
+                        return;
+                    }
+                }
+            }
+
+            // If not a command, or no override is set, then call the original chat handler
+            if (isCommand || _chatChannelOverride == null)
+            {
+                SendMessageHook!.OriginalDisposeSafe(thisPtr, message, uiModule);
+                return;
+            }
+
+            // Otherwise, the text is to be sent to the emulated chat channel handler
+            // The chat input string is rendered in to a payload for display first
+            var chatBytes = ProcessChatMessage(message);
+
+            if (chatBytes.Length > 0)
+                _chatChannelOverride.ChatMessageHandler?.Invoke(chatBytes);
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Exception thrown during SendMessageDetour");
+        }
+    }
+
+    private void SetChatChannelDetour(RaptureShellModule* module, uint channel)
+    {
+        try
+        {
+            if (_chatChannelOverride != null)
+            {
+                _chatChannelOverride = null;
+                _shouldForceNameLookup = true;
+            }
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Exception thrown during SetChatChannelDetour");
+        }
+
+        SetChatChannelHook!.OriginalDisposeSafe(module, channel);
+    }
+
+    private ulong TempChatChannelDetour(RaptureShellModule* module, uint x, uint y, ulong z)
+    {
+        var result = TempChatChannelHook!.OriginalDisposeSafe(module, x, y, z);
+
+        if (result != 0)
+            StashChatChannel();
+
+        return result;
+    }
+
+    private ulong TempTellTargetDetour(RaptureShellModule* module, ulong a, ulong b, ulong c, ushort d, ulong e, ulong f, ushort g)
+    {
+        var result = TempTellTargetHook!.OriginalDisposeSafe(module, a, b, c, d, e, f, g);
+
+        if (result != 0)
+            StashChatChannel();
+
+        return result;
+    }
+
+    private void UnfocusTickDetour(RaptureShellModule* module)
+    {
+        UnfocusTickHook!.OriginalDisposeSafe(module);
+        UnstashChatChannel();
+    }
+
+    private byte* ChangeChannelNameDetour(AgentChatLog* agent)
+    {
+        var originalResult = ChangeChannelNameHook!.OriginalDisposeSafe(agent);
+
+        try
+        {
+            // Replace the chat channel name on the UI if active
+            if (_chatChannelOverride != null)
+            {
+                agent->ChannelLabel.SetString(_chatChannelOverride.ChannelName);
+            }
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Exception thrown during ChangeChannelNameDetour");
+        }
+
+        return originalResult;
+    }
+
+    private byte ShouldDoNameLookupDetour(AgentChatLog* agent)
+    {
+        var originalResult = ShouldDoNameLookupHook!.OriginalDisposeSafe(agent);
+
+        try
+        {
+            // Force the chat channel name to update when required
+            if (_shouldForceNameLookup)
+            {
+                _shouldForceNameLookup = false;
+                return 1;
+            }
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Exception thrown during ShouldDoNameLookupDetour");
+        }
+
+        return originalResult;
+    }
+}

MareSynchronos/Interop/GameModel/MdlFile.cs

@@ -0,0 +1,259 @@
+using Lumina.Data;
+using Lumina.Extensions;
+using System.Runtime.InteropServices;
+using System.Text;
+using static Lumina.Data.Parsing.MdlStructs;
+
+namespace MareSynchronos.Interop.GameModel;
+
+#pragma warning disable S1104 // Fields should not have public accessibility
+
+// This code is completely and shamelessly borrowed from Penumbra to load V5 and V6 model files.
+// Original Source: https://github.com/Ottermandias/Penumbra.GameData/blob/main/Files/MdlFile.cs
+public class MdlFile
+{
+    public const int V5 = 0x01000005;
+    public const int V6 = 0x01000006;
+    public const uint NumVertices = 17;
+    public const uint FileHeaderSize = 0x44;
+
+    // Raw data to write back.
+    public uint Version = 0x01000005;
+    public float Radius;
+    public float ModelClipOutDistance;
+    public float ShadowClipOutDistance;
+    public byte BgChangeMaterialIndex;
+    public byte BgCrestChangeMaterialIndex;
+    public ushort CullingGridCount;
+    public byte Flags3;
+    public byte Unknown6;
+    public ushort Unknown8;
+    public ushort Unknown9;
+
+    // Offsets are stored relative to RuntimeSize instead of file start.
+    public uint[] VertexOffset = [0, 0, 0];
+    public uint[] IndexOffset = [0, 0, 0];
+
+    public uint[] VertexBufferSize = [0, 0, 0];
+    public uint[] IndexBufferSize = [0, 0, 0];
+    public byte LodCount;
+    public bool EnableIndexBufferStreaming;
+    public bool EnableEdgeGeometry;
+
+    public ModelFlags1 Flags1;
+    public ModelFlags2 Flags2;
+
+    public VertexDeclarationStruct[] VertexDeclarations = [];
+    public ElementIdStruct[] ElementIds = [];
+    public MeshStruct[] Meshes = [];
+    public BoundingBoxStruct[] BoneBoundingBoxes = [];
+    public LodStruct[] Lods = [];
+    public ExtraLodStruct[] ExtraLods = [];
+
+    public MdlFile(string filePath)
+    {
+        using var stream = new FileStream(filePath, FileMode.Open, FileAccess.Read);
+        using var r = new LuminaBinaryReader(stream);
+
+        var header = LoadModelFileHeader(r);
+        LodCount = header.LodCount;
+        VertexBufferSize = header.VertexBufferSize;
+        IndexBufferSize = header.IndexBufferSize;
+        VertexOffset = header.VertexOffset;
+        IndexOffset = header.IndexOffset;
+
+        var dataOffset = FileHeaderSize + header.RuntimeSize + header.StackSize;
+        for (var i = 0; i < LodCount; ++i)
+        {
+            VertexOffset[i] -= dataOffset;
+            IndexOffset[i] -= dataOffset;
+        }
+
+        VertexDeclarations = new VertexDeclarationStruct[header.VertexDeclarationCount];
+        for (var i = 0; i < header.VertexDeclarationCount; ++i)
+            VertexDeclarations[i] = VertexDeclarationStruct.Read(r);
+
+        _ = LoadStrings(r);
+
+        var modelHeader = LoadModelHeader(r);
+        ElementIds = new ElementIdStruct[modelHeader.ElementIdCount];
+        for (var i = 0; i < modelHeader.ElementIdCount; i++)
+            ElementIds[i] = ElementIdStruct.Read(r);
+
+        Lods = new LodStruct[3];
+        for (var i = 0; i < 3; i++)
+        {
+            var lod = r.ReadStructure<LodStruct>();
+            if (i < LodCount)
+            {
+                lod.VertexDataOffset -= dataOffset;
+                lod.IndexDataOffset -= dataOffset;
+            }
+
+            Lods[i] = lod;
+        }
+
+        ExtraLods = modelHeader.Flags2.HasFlag(ModelFlags2.ExtraLodEnabled)
+            ? r.ReadStructuresAsArray<ExtraLodStruct>(3)
+            : [];
+
+        Meshes = new MeshStruct[modelHeader.MeshCount];
+        for (var i = 0; i < modelHeader.MeshCount; i++)
+            Meshes[i] = MeshStruct.Read(r);
+    }
+
+    private ModelFileHeader LoadModelFileHeader(LuminaBinaryReader r)
+    {
+        var header = ModelFileHeader.Read(r);
+        Version = header.Version;
+        EnableIndexBufferStreaming = header.EnableIndexBufferStreaming;
+        EnableEdgeGeometry = header.EnableEdgeGeometry;
+        return header;
+    }
+
+    private ModelHeader LoadModelHeader(BinaryReader r)
+    {
+        var modelHeader = r.ReadStructure<ModelHeader>();
+        Radius = modelHeader.Radius;
+        Flags1 = modelHeader.Flags1;
+        Flags2 = modelHeader.Flags2;
+        ModelClipOutDistance = modelHeader.ModelClipOutDistance;
+        ShadowClipOutDistance = modelHeader.ShadowClipOutDistance;
+        CullingGridCount = modelHeader.CullingGridCount;
+        Flags3 = modelHeader.Flags3;
+        Unknown6 = modelHeader.Unknown6;
+        Unknown8 = modelHeader.Unknown8;
+        Unknown9 = modelHeader.Unknown9;
+        BgChangeMaterialIndex = modelHeader.BGChangeMaterialIndex;
+        BgCrestChangeMaterialIndex = modelHeader.BGCrestChangeMaterialIndex;
+
+        return modelHeader;
+    }
+
+    private static (uint[], string[]) LoadStrings(BinaryReader r)
+    {
+        var stringCount = r.ReadUInt16();
+        r.ReadUInt16();
+        var stringSize = (int)r.ReadUInt32();
+        var stringData = r.ReadBytes(stringSize);
+        var start = 0;
+        var strings = new string[stringCount];
+        var offsets = new uint[stringCount];
+        for (var i = 0; i < stringCount; ++i)
+        {
+            var span = stringData.AsSpan(start);
+            var idx = span.IndexOf((byte)'\0');
+            strings[i] = Encoding.UTF8.GetString(span[..idx]);
+            offsets[i] = (uint)start;
+            start = start + idx + 1;
+        }
+
+        return (offsets, strings);
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    public unsafe struct ModelHeader
+    {
+        // MeshHeader
+        public float Radius;
+        public ushort MeshCount;
+        public ushort AttributeCount;
+        public ushort SubmeshCount;
+        public ushort MaterialCount;
+        public ushort BoneCount;
+        public ushort BoneTableCount;
+        public ushort ShapeCount;
+        public ushort ShapeMeshCount;
+        public ushort ShapeValueCount;
+        public byte LodCount;
+        public ModelFlags1 Flags1;
+        public ushort ElementIdCount;
+        public byte TerrainShadowMeshCount;
+        public ModelFlags2 Flags2;
+        public float ModelClipOutDistance;
+        public float ShadowClipOutDistance;
+        public ushort CullingGridCount;
+        public ushort TerrainShadowSubmeshCount;
+        public byte Flags3;
+        public byte BGChangeMaterialIndex;
+        public byte BGCrestChangeMaterialIndex;
+        public byte Unknown6;
+        public ushort BoneTableArrayCountTotal;
+        public ushort Unknown8;
+        public ushort Unknown9;
+        private fixed byte _padding[6];
+    }
+
+    public struct ShapeStruct
+    {
+        public uint StringOffset;
+        public ushort[] ShapeMeshStartIndex;
+        public ushort[] ShapeMeshCount;
+
+        public static ShapeStruct Read(LuminaBinaryReader br)
+        {
+            ShapeStruct ret = new ShapeStruct();
+            ret.StringOffset = br.ReadUInt32();
+            ret.ShapeMeshStartIndex = br.ReadUInt16Array(3);
+            ret.ShapeMeshCount = br.ReadUInt16Array(3);
+            return ret;
+        }
+    }
+
+    [Flags]
+    public enum ModelFlags1 : byte
+    {
+        DustOcclusionEnabled = 0x80,
+        SnowOcclusionEnabled = 0x40,
+        RainOcclusionEnabled = 0x20,
+        Unknown1 = 0x10,
+        LightingReflectionEnabled = 0x08,
+        WavingAnimationDisabled = 0x04,
+        LightShadowDisabled = 0x02,
+        ShadowDisabled = 0x01,
+    }
+
+    [Flags]
+    public enum ModelFlags2 : byte
+    {
+        Unknown2 = 0x80,
+        BgUvScrollEnabled = 0x40,
+        EnableForceNonResident = 0x20,
+        ExtraLodEnabled = 0x10,
+        ShadowMaskEnabled = 0x08,
+        ForceLodRangeEnabled = 0x04,
+        EdgeGeometryEnabled = 0x02,
+        Unknown3 = 0x01
+    }
+
+    public struct VertexDeclarationStruct
+    {
+        // There are always 17, but stop when stream = -1
+        public VertexElement[] VertexElements;
+
+        public static VertexDeclarationStruct Read(LuminaBinaryReader br)
+        {
+            VertexDeclarationStruct ret = new VertexDeclarationStruct();
+
+            var elems = new List<VertexElement>();
+
+            // Read the vertex elements that we need
+            var thisElem = br.ReadStructure<VertexElement>();
+            do
+            {
+                elems.Add(thisElem);
+                thisElem = br.ReadStructure<VertexElement>();
+            } while (thisElem.Stream != 255);
+
+            // Skip the number of bytes that we don't need to read
+            // We skip elems.Count * 9 because we had to read the invalid element
+            int toSeek = 17 * 8 - (elems.Count + 1) * 8;
+            br.Seek(br.BaseStream.Position + toSeek);
+
+            ret.VertexElements = elems.ToArray();
+
+            return ret;
+        }
+    }
+}
+#pragma warning restore S1104 // Fields should not have public accessibility

MareSynchronos/Interop/Ipc/IIpcCaller.cs

@@ -0,0 +1,7 @@
+namespace MareSynchronos.Interop.Ipc;
+
+public interface IIpcCaller : IDisposable
+{
+    bool APIAvailable { get; }
+    void CheckAPI();
+}

MareSynchronos/Interop/Ipc/IpcCallerBrio.cs

@@ -0,0 +1,147 @@
+using Dalamud.Game.ClientState.Objects.Types;
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using MareSynchronos.API.Dto.CharaData;
+using MareSynchronos.Services;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+using System.Text.Json.Nodes;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerBrio : IIpcCaller
+{
+    private readonly ILogger<IpcCallerBrio> _logger;
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly ICallGateSubscriber<(int, int)> _brioApiVersion;
+
+    private readonly ICallGateSubscriber<bool, bool, bool, Task<IGameObject>> _brioSpawnActorAsync;
+    private readonly ICallGateSubscriber<IGameObject, bool> _brioDespawnActor;
+    private readonly ICallGateSubscriber<IGameObject, Vector3?, Quaternion?, Vector3?, bool, bool> _brioSetModelTransform;
+    private readonly ICallGateSubscriber<IGameObject, (Vector3?, Quaternion?, Vector3?)> _brioGetModelTransform;
+    private readonly ICallGateSubscriber<IGameObject, string> _brioGetPoseAsJson;
+    private readonly ICallGateSubscriber<IGameObject, string, bool, bool> _brioSetPoseFromJson;
+    private readonly ICallGateSubscriber<IGameObject, bool> _brioFreezeActor;
+    private readonly ICallGateSubscriber<bool> _brioFreezePhysics;
+
+
+    public bool APIAvailable { get; private set; }
+
+    public IpcCallerBrio(ILogger<IpcCallerBrio> logger, IDalamudPluginInterface dalamudPluginInterface,
+        DalamudUtilService dalamudUtilService)
+    {
+        _logger = logger;
+        _dalamudUtilService = dalamudUtilService;
+
+        _brioApiVersion = dalamudPluginInterface.GetIpcSubscriber<(int, int)>("Brio.ApiVersion");
+        _brioSpawnActorAsync = dalamudPluginInterface.GetIpcSubscriber<bool, bool, bool, Task<IGameObject>>("Brio.Actor.SpawnExAsync");
+        _brioDespawnActor = dalamudPluginInterface.GetIpcSubscriber<IGameObject, bool>("Brio.Actor.Despawn");
+        _brioSetModelTransform = dalamudPluginInterface.GetIpcSubscriber<IGameObject, Vector3?, Quaternion?, Vector3?, bool, bool>("Brio.Actor.SetModelTransform");
+        _brioGetModelTransform = dalamudPluginInterface.GetIpcSubscriber<IGameObject, (Vector3?, Quaternion?, Vector3?)>("Brio.Actor.GetModelTransform");
+        _brioGetPoseAsJson = dalamudPluginInterface.GetIpcSubscriber<IGameObject, string>("Brio.Actor.Pose.GetPoseAsJson");
+        _brioSetPoseFromJson = dalamudPluginInterface.GetIpcSubscriber<IGameObject, string, bool, bool>("Brio.Actor.Pose.LoadFromJson");
+        _brioFreezeActor = dalamudPluginInterface.GetIpcSubscriber<IGameObject, bool>("Brio.Actor.Freeze");
+        _brioFreezePhysics = dalamudPluginInterface.GetIpcSubscriber<bool>("Brio.FreezePhysics");
+
+        CheckAPI();
+    }
+
+    public void CheckAPI()
+    {
+        try
+        {
+            var version = _brioApiVersion.InvokeFunc();
+            APIAvailable = (version.Item1 == 2 && version.Item2 >= 0);
+        }
+        catch
+        {
+            APIAvailable = false;
+        }
+    }
+
+    public async Task<IGameObject?> SpawnActorAsync()
+    {
+        if (!APIAvailable) return null;
+        _logger.LogDebug("Spawning Brio Actor");
+        return await _brioSpawnActorAsync.InvokeFunc(false, false, true).ConfigureAwait(false);
+    }
+
+    public async Task<bool> DespawnActorAsync(nint address)
+    {
+        if (!APIAvailable) return false;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return false;
+        _logger.LogDebug("Despawning Brio Actor {actor}", gameObject.Name.TextValue);
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioDespawnActor.InvokeFunc(gameObject)).ConfigureAwait(false);
+    }
+
+    public async Task<bool> ApplyTransformAsync(nint address, WorldData data)
+    {
+        if (!APIAvailable) return false;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return false;
+        _logger.LogDebug("Applying Transform to Actor {actor}", gameObject.Name.TextValue);
+
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioSetModelTransform.InvokeFunc(gameObject,
+            new Vector3(data.PositionX, data.PositionY, data.PositionZ),
+            new Quaternion(data.RotationX, data.RotationY, data.RotationZ, data.RotationW),
+            new Vector3(data.ScaleX, data.ScaleY, data.ScaleZ), false)).ConfigureAwait(false);
+    }
+
+    public async Task<WorldData> GetTransformAsync(nint address)
+    {
+        if (!APIAvailable) return default;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return default;
+        var data = await _dalamudUtilService.RunOnFrameworkThread(() => _brioGetModelTransform.InvokeFunc(gameObject)).ConfigureAwait(false);
+        if (data.Item1 == null || data.Item2 == null || data.Item3 == null) return default;
+        //_logger.LogDebug("Getting Transform from Actor {actor}", gameObject.Name.TextValue);
+
+        return new WorldData()
+        {
+            PositionX = data.Item1.Value.X,
+            PositionY = data.Item1.Value.Y,
+            PositionZ = data.Item1.Value.Z,
+            RotationX = data.Item2.Value.X,
+            RotationY = data.Item2.Value.Y,
+            RotationZ = data.Item2.Value.Z,
+            RotationW = data.Item2.Value.W,
+            ScaleX = data.Item3.Value.X,
+            ScaleY = data.Item3.Value.Y,
+            ScaleZ = data.Item3.Value.Z
+        };
+    }
+
+    public async Task<string?> GetPoseAsync(nint address)
+    {
+        if (!APIAvailable) return null;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return null;
+        _logger.LogDebug("Getting Pose from Actor {actor}", gameObject.Name.TextValue);
+
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioGetPoseAsJson.InvokeFunc(gameObject)).ConfigureAwait(false);
+    }
+
+    public async Task<bool> SetPoseAsync(nint address, string pose)
+    {
+        if (!APIAvailable) return false;
+        var gameObject = await _dalamudUtilService.CreateGameObjectAsync(address).ConfigureAwait(false);
+        if (gameObject == null) return false;
+        _logger.LogDebug("Setting Pose to Actor {actor}", gameObject.Name.TextValue);
+
+        var applicablePose = JsonNode.Parse(pose)!;
+        var currentPose = await _dalamudUtilService.RunOnFrameworkThread(() => _brioGetPoseAsJson.InvokeFunc(gameObject)).ConfigureAwait(false);
+        applicablePose["ModelDifference"] = JsonNode.Parse(JsonNode.Parse(currentPose)!["ModelDifference"]!.ToJsonString());
+
+        await _dalamudUtilService.RunOnFrameworkThread(() =>
+        {
+            _brioFreezeActor.InvokeFunc(gameObject);
+            _brioFreezePhysics.InvokeFunc();
+        }).ConfigureAwait(false);
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioSetPoseFromJson.InvokeFunc(gameObject, applicablePose.ToJsonString(), false)).ConfigureAwait(false);
+    }
+
+    public void Dispose()
+    {
+    }
+}

MareSynchronos/Interop/Ipc/IpcCallerCustomize.cs

@@ -0,0 +1,139 @@
+using Dalamud.Game.ClientState.Objects.Types;
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using Dalamud.Utility;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Text;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerCustomize : IIpcCaller
+{
+    private readonly ICallGateSubscriber<(int, int)> _customizePlusApiVersion;
+    private readonly ICallGateSubscriber<ushort, (int, Guid?)> _customizePlusGetActiveProfile;
+    private readonly ICallGateSubscriber<Guid, (int, string?)> _customizePlusGetProfileById;
+    private readonly ICallGateSubscriber<ushort, Guid, object> _customizePlusOnScaleUpdate;
+    private readonly ICallGateSubscriber<ushort, int> _customizePlusRevertCharacter;
+    private readonly ICallGateSubscriber<ushort, string, (int, Guid?)> _customizePlusSetBodyScaleToCharacter;
+    private readonly ICallGateSubscriber<Guid, int> _customizePlusDeleteByUniqueId;
+    private readonly ILogger<IpcCallerCustomize> _logger;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly MareMediator _mareMediator;
+
+    public IpcCallerCustomize(ILogger<IpcCallerCustomize> logger, IDalamudPluginInterface dalamudPluginInterface,
+        DalamudUtilService dalamudUtil, MareMediator mareMediator)
+    {
+        _customizePlusApiVersion = dalamudPluginInterface.GetIpcSubscriber<(int, int)>("CustomizePlus.General.GetApiVersion");
+        _customizePlusGetActiveProfile = dalamudPluginInterface.GetIpcSubscriber<ushort, (int, Guid?)>("CustomizePlus.Profile.GetActiveProfileIdOnCharacter");
+        _customizePlusGetProfileById = dalamudPluginInterface.GetIpcSubscriber<Guid, (int, string?)>("CustomizePlus.Profile.GetByUniqueId");
+        _customizePlusRevertCharacter = dalamudPluginInterface.GetIpcSubscriber<ushort, int>("CustomizePlus.Profile.DeleteTemporaryProfileOnCharacter");
+        _customizePlusSetBodyScaleToCharacter = dalamudPluginInterface.GetIpcSubscriber<ushort, string, (int, Guid?)>("CustomizePlus.Profile.SetTemporaryProfileOnCharacter");
+        _customizePlusOnScaleUpdate = dalamudPluginInterface.GetIpcSubscriber<ushort, Guid, object>("CustomizePlus.Profile.OnUpdate");
+        _customizePlusDeleteByUniqueId = dalamudPluginInterface.GetIpcSubscriber<Guid, int>("CustomizePlus.Profile.DeleteTemporaryProfileByUniqueId");
+
+        _customizePlusOnScaleUpdate.Subscribe(OnCustomizePlusScaleChange);
+        _logger = logger;
+        _dalamudUtil = dalamudUtil;
+        _mareMediator = mareMediator;
+
+        CheckAPI();
+    }
+
+    public bool APIAvailable { get; private set; } = false;
+
+    public async Task RevertAsync(nint character)
+    {
+        if (!APIAvailable) return;
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var gameObj = _dalamudUtil.CreateGameObject(character);
+            if (gameObj is ICharacter c)
+            {
+                _logger.LogTrace("CustomizePlus reverting for {chara}", c.Address.ToString("X"));
+                _customizePlusRevertCharacter!.InvokeFunc(c.ObjectIndex);
+            }
+        }).ConfigureAwait(false);
+    }
+
+    public async Task<Guid?> SetBodyScaleAsync(nint character, string scale)
+    {
+        if (!APIAvailable) return null;
+        return await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var gameObj = _dalamudUtil.CreateGameObject(character);
+            if (gameObj is ICharacter c)
+            {
+                string decodedScale = Encoding.UTF8.GetString(Convert.FromBase64String(scale));
+                _logger.LogTrace("CustomizePlus applying for {chara}", c.Address.ToString("X"));
+                if (scale.IsNullOrEmpty())
+                {
+                    _customizePlusRevertCharacter!.InvokeFunc(c.ObjectIndex);
+                    return null;
+                }
+                else
+                {
+                    var result = _customizePlusSetBodyScaleToCharacter!.InvokeFunc(c.ObjectIndex, decodedScale);
+                    return result.Item2;
+                }
+            }
+
+            return null;
+        }).ConfigureAwait(false);
+    }
+
+    public async Task RevertByIdAsync(Guid? profileId)
+    {
+        if (!APIAvailable || profileId == null) return;
+
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            _ = _customizePlusDeleteByUniqueId.InvokeFunc(profileId.Value);
+        }).ConfigureAwait(false);
+    }
+
+    public async Task<string?> GetScaleAsync(nint character)
+    {
+        if (!APIAvailable) return null;
+        var scale = await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var gameObj = _dalamudUtil.CreateGameObject(character);
+            if (gameObj is ICharacter c)
+            {
+                var res = _customizePlusGetActiveProfile.InvokeFunc(c.ObjectIndex);
+                _logger.LogTrace("CustomizePlus GetActiveProfile returned {err}", res.Item1);
+                if (res.Item1 != 0 || res.Item2 == null) return string.Empty;
+                return _customizePlusGetProfileById.InvokeFunc(res.Item2.Value).Item2;
+            }
+
+            return string.Empty;
+        }).ConfigureAwait(false);
+        if (string.IsNullOrEmpty(scale)) return string.Empty;
+        return Convert.ToBase64String(Encoding.UTF8.GetBytes(scale));
+    }
+
+    public void CheckAPI()
+    {
+        try
+        {
+            var version = _customizePlusApiVersion.InvokeFunc();
+            APIAvailable = (version.Item1 == 6 && version.Item2 >= 0);
+        }
+        catch
+        {
+            APIAvailable = false;
+        }
+    }
+
+    private void OnCustomizePlusScaleChange(ushort c, Guid g)
+    {
+        var obj = _dalamudUtil.GetCharacterFromObjectTableByIndex(c);
+        _mareMediator.Publish(new CustomizePlusMessage(obj?.Address ?? null));
+    }
+
+    public void Dispose()
+    {
+        _customizePlusOnScaleUpdate.Unsubscribe(OnCustomizePlusScaleChange);
+    }
+}

MareSynchronos/Interop/Ipc/IpcCallerGlamourer.cs

@@ -0,0 +1,253 @@
+using Dalamud.Game.ClientState.Objects.Types;
+using Dalamud.Plugin;
+using Glamourer.Api.Helpers;
+using Glamourer.Api.IpcSubscribers;
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerGlamourer : DisposableMediatorSubscriberBase, IIpcCaller
+{
+    private readonly ILogger<IpcCallerGlamourer> _logger;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly MareMediator _mareMediator;
+    private readonly RedrawManager _redrawManager;
+
+    private readonly ApiVersion _glamourerApiVersions;
+    private readonly ApplyState? _glamourerApplyAll;
+    private readonly GetStateBase64? _glamourerGetAllCustomization;
+    private readonly RevertState _glamourerRevert;
+    private readonly RevertStateName _glamourerRevertByName;
+    private readonly UnlockState _glamourerUnlock;
+    private readonly UnlockStateName _glamourerUnlockByName;
+    private readonly EventSubscriber<nint>? _glamourerStateChanged;
+
+    private bool _pluginLoaded;
+    private Version _pluginVersion;
+
+    private bool _shownGlamourerUnavailable = false;
+    private readonly uint LockCode = 0x626E7579;
+
+    public IpcCallerGlamourer(ILogger<IpcCallerGlamourer> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil, MareMediator mareMediator,
+        RedrawManager redrawManager) : base(logger, mareMediator)
+    {
+        _glamourerApiVersions = new ApiVersion(pi);
+        _glamourerGetAllCustomization = new GetStateBase64(pi);
+        _glamourerApplyAll = new ApplyState(pi);
+        _glamourerRevert = new RevertState(pi);
+        _glamourerRevertByName = new RevertStateName(pi);
+        _glamourerUnlock = new UnlockState(pi);
+        _glamourerUnlockByName = new UnlockStateName(pi);
+
+        _logger = logger;
+        _dalamudUtil = dalamudUtil;
+        _mareMediator = mareMediator;
+        _redrawManager = redrawManager;
+
+        var plugin = PluginWatcherService.GetInitialPluginState(pi, "Glamourer");
+
+        _pluginLoaded = plugin?.IsLoaded ?? false;
+        _pluginVersion = plugin?.Version ?? new(0, 0, 0, 0);
+
+        Mediator.SubscribeKeyed<PluginChangeMessage>(this, "Glamourer", (msg) =>
+        {
+             _pluginLoaded = msg.IsLoaded;
+             _pluginVersion = msg.Version;
+             CheckAPI();
+        });
+
+        CheckAPI();
+
+        _glamourerStateChanged = StateChanged.Subscriber(pi, GlamourerChanged);
+        _glamourerStateChanged.Enable();
+
+        Mediator.Subscribe<DalamudLoginMessage>(this, s => _shownGlamourerUnavailable = false);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        _redrawManager.Cancel();
+        _glamourerStateChanged?.Dispose();
+    }
+
+    public bool APIAvailable { get; private set; }
+
+    public void CheckAPI()
+    {
+        bool apiAvailable = false;
+        try
+        {
+            bool versionValid = _pluginLoaded && _pluginVersion >= new Version(1, 0, 6, 1);
+            try
+            {
+                var version = _glamourerApiVersions.Invoke();
+                if (version is { Major: 1, Minor: >= 1 } && versionValid)
+                {
+                    apiAvailable = true;
+                }
+            }
+            catch
+            {
+                // ignore
+            }
+            _shownGlamourerUnavailable = _shownGlamourerUnavailable && !apiAvailable;
+
+            APIAvailable = apiAvailable;
+        }
+        catch
+        {
+            APIAvailable = apiAvailable;
+        }
+        finally
+        {
+            if (!apiAvailable && !_shownGlamourerUnavailable)
+            {
+                _shownGlamourerUnavailable = true;
+                _mareMediator.Publish(new NotificationMessage("Glamourer inactive", "Your Glamourer installation is not active or out of date. Update Glamourer to continue to use Elezen. If you just updated Glamourer, ignore this message.",
+                    NotificationType.Error));
+            }
+        }
+    }
+
+    public async Task ApplyAllAsync(ILogger logger, GameObjectHandler handler, string? customization, Guid applicationId, CancellationToken token, bool allowImmediate = false)
+    {
+        if (!APIAvailable || string.IsNullOrEmpty(customization) || _dalamudUtil.IsZoning) return;
+
+        // Call immediately if possible
+        if (allowImmediate && _dalamudUtil.IsOnFrameworkThread && !await handler.IsBeingDrawnRunOnFrameworkAsync().ConfigureAwait(false))
+        {
+            var gameObj = await _dalamudUtil.CreateGameObjectAsync(handler.Address).ConfigureAwait(false);
+            if (gameObj is ICharacter chara)
+            {
+                logger.LogDebug("[{appid}] Calling on IPC: GlamourerApplyAll", applicationId);
+                _glamourerApplyAll!.Invoke(customization, chara.ObjectIndex, LockCode);
+                return;
+            }
+        }
+
+        await _redrawManager.RedrawSemaphore.WaitAsync(token).ConfigureAwait(false);
+
+        try
+        {
+            await _redrawManager.PenumbraRedrawInternalAsync(logger, handler, applicationId, (chara) =>
+            {
+                try
+                {
+                    logger.LogDebug("[{appid}] Calling on IPC: GlamourerApplyAll", applicationId);
+                    _glamourerApplyAll!.Invoke(customization, chara.ObjectIndex, LockCode);
+                }
+                catch (Exception ex)
+                {
+                    logger.LogWarning(ex, "[{appid}] Failed to apply Glamourer data", applicationId);
+                }
+            }, token).ConfigureAwait(false);
+        }
+        finally
+        {
+            _redrawManager.RedrawSemaphore.Release();
+        }
+    }
+
+    public async Task<string> GetCharacterCustomizationAsync(IntPtr character)
+    {
+        if (!APIAvailable) return string.Empty;
+        try
+        {
+            return await _dalamudUtil.RunOnFrameworkThread(() =>
+            {
+                var gameObj = _dalamudUtil.CreateGameObject(character);
+                if (gameObj is ICharacter c)
+                {
+                    return _glamourerGetAllCustomization!.Invoke(c.ObjectIndex).Item2 ?? string.Empty;
+                }
+                return string.Empty;
+            }).ConfigureAwait(false);
+        }
+        catch
+        {
+            return string.Empty;
+        }
+    }
+
+    public async Task RevertAsync(ILogger logger, GameObjectHandler handler, Guid applicationId, CancellationToken token)
+    {
+        if ((!APIAvailable) || _dalamudUtil.IsZoning) return;
+        try
+        {
+            await _redrawManager.RedrawSemaphore.WaitAsync(token).ConfigureAwait(false);
+            await _redrawManager.PenumbraRedrawInternalAsync(logger, handler, applicationId, (chara) =>
+            {
+                try
+                {
+                    logger.LogDebug("[{appid}] Calling On IPC: GlamourerUnlock", applicationId);
+                    _glamourerUnlock.Invoke(chara.ObjectIndex, LockCode);
+                    logger.LogDebug("[{appid}] Calling On IPC: GlamourerRevert", applicationId);
+                    _glamourerRevert.Invoke(chara.ObjectIndex, LockCode);
+                    logger.LogDebug("[{appid}] Calling On IPC: PenumbraRedraw", applicationId);
+                    _mareMediator.Publish(new PenumbraRedrawCharacterMessage(chara));
+                }
+                catch (Exception ex)
+                {
+                    logger.LogWarning(ex, "[{appid}] Error during GlamourerRevert", applicationId);
+                }
+            }, token).ConfigureAwait(false);
+        }
+        finally
+        {
+            _redrawManager.RedrawSemaphore.Release();
+        }
+    }
+
+    public void RevertNow(ILogger logger, Guid applicationId, int objectIndex)
+    {
+        if ((!APIAvailable) || _dalamudUtil.IsZoning) return;
+        logger.LogTrace("[{applicationId}] Immediately reverting object index {objId}", applicationId, objectIndex);
+        _glamourerRevert.Invoke(objectIndex, LockCode);
+    }
+
+    public void RevertByNameNow(ILogger logger, Guid applicationId, string name)
+    {
+        if ((!APIAvailable) || _dalamudUtil.IsZoning) return;
+        logger.LogTrace("[{applicationId}] Immediately reverting {name}", applicationId, name);
+        _glamourerRevertByName.Invoke(name, LockCode);
+    }
+
+    public async Task RevertByNameAsync(ILogger logger, string name, Guid applicationId)
+    {
+        if ((!APIAvailable) || _dalamudUtil.IsZoning) return;
+
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            RevertByName(logger, name, applicationId);
+
+        }).ConfigureAwait(false);
+    }
+
+    public void RevertByName(ILogger logger, string name, Guid applicationId)
+    {
+        if ((!APIAvailable) || _dalamudUtil.IsZoning) return;
+
+        try
+        {
+            logger.LogDebug("[{appid}] Calling On IPC: GlamourerRevertByName", applicationId);
+            _glamourerRevertByName.Invoke(name, LockCode);
+            logger.LogDebug("[{appid}] Calling On IPC: GlamourerUnlockName", applicationId);
+            _glamourerUnlockByName.Invoke(name, LockCode);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error during Glamourer RevertByName");
+        }
+    }
+
+    private void GlamourerChanged(nint address)
+    {
+        _mareMediator.Publish(new GlamourerChangedMessage(address));
+    }
+}

MareSynchronos/Interop/Ipc/IpcCallerHeels.cs

@@ -0,0 +1,93 @@
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerHeels : IIpcCaller
+{
+    private readonly ILogger<IpcCallerHeels> _logger;
+    private readonly MareMediator _mareMediator;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly ICallGateSubscriber<(int, int)> _heelsGetApiVersion;
+    private readonly ICallGateSubscriber<string> _heelsGetOffset;
+    private readonly ICallGateSubscriber<string, object?> _heelsOffsetUpdate;
+    private readonly ICallGateSubscriber<int, string, object?> _heelsRegisterPlayer;
+    private readonly ICallGateSubscriber<int, object?> _heelsUnregisterPlayer;
+
+    public IpcCallerHeels(ILogger<IpcCallerHeels> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil, MareMediator mareMediator)
+    {
+        _logger = logger;
+        _mareMediator = mareMediator;
+        _dalamudUtil = dalamudUtil;
+        _heelsGetApiVersion = pi.GetIpcSubscriber<(int, int)>("SimpleHeels.ApiVersion");
+        _heelsGetOffset = pi.GetIpcSubscriber<string>("SimpleHeels.GetLocalPlayer");
+        _heelsRegisterPlayer = pi.GetIpcSubscriber<int, string, object?>("SimpleHeels.RegisterPlayer");
+        _heelsUnregisterPlayer = pi.GetIpcSubscriber<int, object?>("SimpleHeels.UnregisterPlayer");
+        _heelsOffsetUpdate = pi.GetIpcSubscriber<string, object?>("SimpleHeels.LocalChanged");
+
+        _heelsOffsetUpdate.Subscribe(HeelsOffsetChange);
+
+        CheckAPI();
+    }
+
+    public bool APIAvailable { get; private set; } = false;
+
+    private void HeelsOffsetChange(string offset)
+    {
+        _mareMediator.Publish(new HeelsOffsetMessage());
+    }
+
+    public async Task<string> GetOffsetAsync()
+    {
+        if (!APIAvailable) return string.Empty;
+        return await _dalamudUtil.RunOnFrameworkThread(_heelsGetOffset.InvokeFunc).ConfigureAwait(false);
+    }
+
+    public async Task RestoreOffsetForPlayerAsync(IntPtr character)
+    {
+        if (!APIAvailable) return;
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var gameObj = _dalamudUtil.CreateGameObject(character);
+            if (gameObj != null)
+            {
+                _logger.LogTrace("Restoring Heels data to {chara}", character.ToString("X"));
+                _heelsUnregisterPlayer.InvokeAction(gameObj.ObjectIndex);
+            }
+        }).ConfigureAwait(false);
+    }
+
+    public async Task SetOffsetForPlayerAsync(IntPtr character, string data)
+    {
+        if (!APIAvailable) return;
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var gameObj = _dalamudUtil.CreateGameObject(character);
+            if (gameObj != null)
+            {
+                _logger.LogTrace("Applying Heels data to {chara}", character.ToString("X"));
+                _heelsRegisterPlayer.InvokeAction(gameObj.ObjectIndex, data);
+            }
+        }).ConfigureAwait(false);
+    }
+
+    public void CheckAPI()
+    {
+        try
+        {
+            APIAvailable = _heelsGetApiVersion.InvokeFunc() is { Item1: 2, Item2: >= 0 };
+        }
+        catch
+        {
+            APIAvailable = false;
+        }
+    }
+
+    public void Dispose()
+    {
+        _heelsOffsetUpdate.Unsubscribe(HeelsOffsetChange);
+    }
+}

MareSynchronos/Interop/Ipc/IpcCallerHonorific.cs

@@ -0,0 +1,135 @@
+using Dalamud.Game.ClientState.Objects.SubKinds;
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Text;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerHonorific : IIpcCaller
+{
+    private readonly ICallGateSubscriber<(uint major, uint minor)> _honorificApiVersion;
+    private readonly ICallGateSubscriber<int, object> _honorificClearCharacterTitle;
+    private readonly ICallGateSubscriber<object> _honorificDisposing;
+    private readonly ICallGateSubscriber<string> _honorificGetLocalCharacterTitle;
+    private readonly ICallGateSubscriber<string, object> _honorificLocalCharacterTitleChanged;
+    private readonly ICallGateSubscriber<object> _honorificReady;
+    private readonly ICallGateSubscriber<int, string, object> _honorificSetCharacterTitle;
+    private readonly ILogger<IpcCallerHonorific> _logger;
+    private readonly MareMediator _mareMediator;
+    private readonly DalamudUtilService _dalamudUtil;
+
+    public IpcCallerHonorific(ILogger<IpcCallerHonorific> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil,
+        MareMediator mareMediator)
+    {
+        _logger = logger;
+        _mareMediator = mareMediator;
+        _dalamudUtil = dalamudUtil;
+        _honorificApiVersion = pi.GetIpcSubscriber<(uint, uint)>("Honorific.ApiVersion");
+        _honorificGetLocalCharacterTitle = pi.GetIpcSubscriber<string>("Honorific.GetLocalCharacterTitle");
+        _honorificClearCharacterTitle = pi.GetIpcSubscriber<int, object>("Honorific.ClearCharacterTitle");
+        _honorificSetCharacterTitle = pi.GetIpcSubscriber<int, string, object>("Honorific.SetCharacterTitle");
+        _honorificLocalCharacterTitleChanged = pi.GetIpcSubscriber<string, object>("Honorific.LocalCharacterTitleChanged");
+        _honorificDisposing = pi.GetIpcSubscriber<object>("Honorific.Disposing");
+        _honorificReady = pi.GetIpcSubscriber<object>("Honorific.Ready");
+
+        _honorificLocalCharacterTitleChanged.Subscribe(OnHonorificLocalCharacterTitleChanged);
+        _honorificDisposing.Subscribe(OnHonorificDisposing);
+        _honorificReady.Subscribe(OnHonorificReady);
+
+        CheckAPI();
+    }
+
+    public bool APIAvailable { get; private set; } = false;
+
+    public void CheckAPI()
+    {
+        try
+        {
+            APIAvailable = _honorificApiVersion.InvokeFunc() is { Item1: 3, Item2: >= 0 };
+        }
+        catch
+        {
+            APIAvailable = false;
+        }
+    }
+
+    public void Dispose()
+    {
+        _honorificLocalCharacterTitleChanged.Unsubscribe(OnHonorificLocalCharacterTitleChanged);
+        _honorificDisposing.Unsubscribe(OnHonorificDisposing);
+        _honorificReady.Unsubscribe(OnHonorificReady);
+    }
+
+    public async Task ClearTitleAsync(nint character)
+    {
+        if (!APIAvailable) return;
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var gameObj = _dalamudUtil.CreateGameObject(character);
+            if (gameObj is IPlayerCharacter c)
+            {
+                _logger.LogTrace("Honorific removing for {addr}", c.Address.ToString("X"));
+                _honorificClearCharacterTitle!.InvokeAction(c.ObjectIndex);
+            }
+        }).ConfigureAwait(false);
+    }
+
+    public async Task<string> GetTitle()
+    {
+        if (!APIAvailable) return string.Empty;
+        return await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            string title = _honorificGetLocalCharacterTitle.InvokeFunc();
+            return string.IsNullOrEmpty(title) ? string.Empty : Convert.ToBase64String(Encoding.UTF8.GetBytes(title));
+        }).ConfigureAwait(false);
+    }
+
+    public async Task SetTitleAsync(IntPtr character, string honorificDataB64)
+    {
+        if (!APIAvailable) return;
+        _logger.LogTrace("Applying Honorific data to {chara}", character.ToString("X"));
+        try
+        {
+            await _dalamudUtil.RunOnFrameworkThread(() =>
+            {
+                var gameObj = _dalamudUtil.CreateGameObject(character);
+                if (gameObj is IPlayerCharacter pc)
+                {
+                    string honorificData = string.IsNullOrEmpty(honorificDataB64) ? string.Empty : Encoding.UTF8.GetString(Convert.FromBase64String(honorificDataB64));
+                    if (string.IsNullOrEmpty(honorificData))
+                    {
+                        _honorificClearCharacterTitle!.InvokeAction(pc.ObjectIndex);
+                    }
+                    else
+                    {
+                        _honorificSetCharacterTitle!.InvokeAction(pc.ObjectIndex, honorificData);
+                    }
+                }
+            }).ConfigureAwait(false);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Could not apply Honorific data");
+        }
+    }
+
+    private void OnHonorificDisposing()
+    {
+        _mareMediator.Publish(new HonorificMessage(string.Empty));
+    }
+
+    private void OnHonorificLocalCharacterTitleChanged(string titleJson)
+    {
+        string titleData = string.IsNullOrEmpty(titleJson) ? string.Empty : Convert.ToBase64String(Encoding.UTF8.GetBytes(titleJson));
+        _mareMediator.Publish(new HonorificMessage(titleData));
+    }
+
+    private void OnHonorificReady()
+    {
+        CheckAPI();
+        _mareMediator.Publish(new HonorificReadyMessage());
+    }
+}

MareSynchronos/Interop/Ipc/IpcCallerMare.cs

@@ -0,0 +1,44 @@
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerMare : DisposableMediatorSubscriberBase
+{
+    private readonly ICallGateSubscriber<List<nint>> _mareHandledGameAddresses;
+    private readonly List<nint> _emptyList = [];
+
+    private bool _pluginLoaded;
+
+    public IpcCallerMare(ILogger<IpcCallerMare> logger, IDalamudPluginInterface pi,  MareMediator mediator) : base(logger, mediator)
+    {
+        _mareHandledGameAddresses = pi.GetIpcSubscriber<List<nint>>("MareSynchronos.GetHandledAddresses");
+
+        _pluginLoaded = PluginWatcherService.GetInitialPluginState(pi, "MareSynchronos")?.IsLoaded ?? false;
+
+        Mediator.SubscribeKeyed<PluginChangeMessage>(this, "MareSynchronos", (msg) =>
+        {
+            _pluginLoaded = msg.IsLoaded;
+        });
+    }
+
+    public bool APIAvailable { get; private set; } = false;
+
+    // Must be called on framework thread
+    public IReadOnlyList<nint> GetHandledGameAddresses()
+    {
+        if (!_pluginLoaded) return _emptyList;
+
+        try
+        {
+            return _mareHandledGameAddresses.InvokeFunc();
+        }
+        catch
+        {
+            return _emptyList;
+        }
+    }
+}

MareSynchronos/Interop/Ipc/IpcCallerMoodles.cs

@@ -0,0 +1,104 @@
+using Dalamud.Game.ClientState.Objects.SubKinds;
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerMoodles : IIpcCaller
+{
+    private readonly ICallGateSubscriber<int> _moodlesApiVersion;
+    private readonly ICallGateSubscriber<IPlayerCharacter, object> _moodlesOnChange;
+    private readonly ICallGateSubscriber<nint, string> _moodlesGetStatus;
+    private readonly ICallGateSubscriber<nint, string, object> _moodlesSetStatus;
+    private readonly ICallGateSubscriber<nint, object> _moodlesRevertStatus;
+    private readonly ILogger<IpcCallerMoodles> _logger;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly MareMediator _mareMediator;
+
+    public IpcCallerMoodles(ILogger<IpcCallerMoodles> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil,
+        MareMediator mareMediator)
+    {
+        _logger = logger;
+        _dalamudUtil = dalamudUtil;
+        _mareMediator = mareMediator;
+
+        _moodlesApiVersion = pi.GetIpcSubscriber<int>("Moodles.Version");
+        _moodlesOnChange = pi.GetIpcSubscriber<IPlayerCharacter, object>("Moodles.StatusManagerModified");
+        _moodlesGetStatus = pi.GetIpcSubscriber<nint, string>("Moodles.GetStatusManagerByPtr");
+        _moodlesSetStatus = pi.GetIpcSubscriber<nint, string, object>("Moodles.SetStatusManagerByPtr");
+        _moodlesRevertStatus = pi.GetIpcSubscriber<nint, object>("Moodles.ClearStatusManagerByPtr");
+
+        _moodlesOnChange.Subscribe(OnMoodlesChange);
+
+        CheckAPI();
+    }
+
+    private void OnMoodlesChange(IPlayerCharacter character)
+    {
+        _mareMediator.Publish(new MoodlesMessage(character.Address));
+    }
+
+    public bool APIAvailable { get; private set; } = false;
+
+    public void CheckAPI()
+    {
+        try
+        {
+            APIAvailable = _moodlesApiVersion.InvokeFunc() == 1;
+        }
+        catch
+        {
+            APIAvailable = false;
+        }
+    }
+
+    public void Dispose()
+    {
+        _moodlesOnChange.Unsubscribe(OnMoodlesChange);
+    }
+
+    public async Task<string?> GetStatusAsync(nint address)
+    {
+        if (!APIAvailable) return null;
+
+        try
+        {
+            return await _dalamudUtil.RunOnFrameworkThread(() => _moodlesGetStatus.InvokeFunc(address)).ConfigureAwait(false);
+
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Could not Get Moodles Status");
+            return null;
+        }
+    }
+
+    public async Task SetStatusAsync(nint pointer, string status)
+    {
+        if (!APIAvailable) return;
+        try
+        {
+            await _dalamudUtil.RunOnFrameworkThread(() => _moodlesSetStatus.InvokeAction(pointer, status)).ConfigureAwait(false);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Could not Set Moodles Status");
+        }
+    }
+
+    public async Task RevertStatusAsync(nint pointer)
+    {
+        if (!APIAvailable) return;
+        try
+        {
+            await _dalamudUtil.RunOnFrameworkThread(() => _moodlesRevertStatus.InvokeAction(pointer)).ConfigureAwait(false);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Could not Set Moodles Status");
+        }
+    }
+}

MareSynchronos/Interop/Ipc/IpcCallerPenumbra.cs

@@ -0,0 +1,360 @@
+using Dalamud.Plugin;
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using Penumbra.Api.Enums;
+using Penumbra.Api.Helpers;
+using Penumbra.Api.IpcSubscribers;
+using System.Collections.Concurrent;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerPenumbra : DisposableMediatorSubscriberBase, IIpcCaller
+{
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly MareMediator _mareMediator;
+    private readonly RedrawManager _redrawManager;
+    private bool _shownPenumbraUnavailable = false;
+    private string? _penumbraModDirectory;
+    public string? ModDirectory
+    {
+        get => _penumbraModDirectory;
+        private set
+        {
+            if (!string.Equals(_penumbraModDirectory, value, StringComparison.Ordinal))
+            {
+                _penumbraModDirectory = value;
+                _mareMediator.Publish(new PenumbraDirectoryChangedMessage(_penumbraModDirectory));
+            }
+        }
+    }
+
+    private readonly ConcurrentDictionary<IntPtr, bool> _penumbraRedrawRequests = new();
+
+    private readonly EventSubscriber _penumbraDispose;
+    private readonly EventSubscriber<nint, string, string> _penumbraGameObjectResourcePathResolved;
+    private readonly EventSubscriber _penumbraInit;
+    private readonly EventSubscriber<ModSettingChange, Guid, string, bool> _penumbraModSettingChanged;
+    private readonly EventSubscriber<nint, int> _penumbraObjectIsRedrawn;
+
+    private readonly AddTemporaryMod _penumbraAddTemporaryMod;
+    private readonly AssignTemporaryCollection _penumbraAssignTemporaryCollection;
+    private readonly ConvertTextureFile _penumbraConvertTextureFile;
+    private readonly CreateTemporaryCollection _penumbraCreateNamedTemporaryCollection;
+    private readonly GetEnabledState _penumbraEnabled;
+    private readonly GetPlayerMetaManipulations _penumbraGetMetaManipulations;
+    private readonly RedrawObject _penumbraRedraw;
+    private readonly DeleteTemporaryCollection _penumbraRemoveTemporaryCollection;
+    private readonly RemoveTemporaryMod _penumbraRemoveTemporaryMod;
+    private readonly GetModDirectory _penumbraResolveModDir;
+    private readonly ResolvePlayerPathsAsync _penumbraResolvePaths;
+    private readonly GetGameObjectResourcePaths _penumbraResourcePaths;
+
+    private bool _pluginLoaded;
+    private Version _pluginVersion;
+
+    public IpcCallerPenumbra(ILogger<IpcCallerPenumbra> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil,
+        MareMediator mareMediator, RedrawManager redrawManager) : base(logger, mareMediator)
+    {
+        _dalamudUtil = dalamudUtil;
+        _mareMediator = mareMediator;
+        _redrawManager = redrawManager;
+        _penumbraInit = Initialized.Subscriber(pi, PenumbraInit);
+        _penumbraDispose = Disposed.Subscriber(pi, PenumbraDispose);
+        _penumbraResolveModDir = new GetModDirectory(pi);
+        _penumbraRedraw = new RedrawObject(pi);
+        _penumbraObjectIsRedrawn = GameObjectRedrawn.Subscriber(pi, RedrawEvent);
+        _penumbraGetMetaManipulations = new GetPlayerMetaManipulations(pi);
+        _penumbraRemoveTemporaryMod = new RemoveTemporaryMod(pi);
+        _penumbraAddTemporaryMod = new AddTemporaryMod(pi);
+        _penumbraCreateNamedTemporaryCollection = new CreateTemporaryCollection(pi);
+        _penumbraRemoveTemporaryCollection = new DeleteTemporaryCollection(pi);
+        _penumbraAssignTemporaryCollection = new AssignTemporaryCollection(pi);
+        _penumbraResolvePaths = new ResolvePlayerPathsAsync(pi);
+        _penumbraEnabled = new GetEnabledState(pi);
+        _penumbraModSettingChanged = ModSettingChanged.Subscriber(pi, (change, arg1, arg, b) =>
+        {
+            if (change == ModSettingChange.EnableState)
+                _mareMediator.Publish(new PenumbraModSettingChangedMessage());
+        });
+        _penumbraConvertTextureFile = new ConvertTextureFile(pi);
+        _penumbraResourcePaths = new GetGameObjectResourcePaths(pi);
+
+        _penumbraGameObjectResourcePathResolved = GameObjectResourcePathResolved.Subscriber(pi, ResourceLoaded);
+
+        var plugin = PluginWatcherService.GetInitialPluginState(pi, "Penumbra");
+
+        _pluginLoaded = plugin?.IsLoaded ?? false;
+        _pluginVersion = plugin?.Version ?? new(0, 0, 0, 0);
+
+        Mediator.SubscribeKeyed<PluginChangeMessage>(this, "Penumbra", (msg) =>
+        {
+             _pluginLoaded = msg.IsLoaded;
+             _pluginVersion = msg.Version;
+             CheckAPI();
+        });
+
+        CheckAPI();
+        CheckModDirectory();
+
+        Mediator.Subscribe<PenumbraRedrawCharacterMessage>(this, (msg) =>
+        {
+            _penumbraRedraw.Invoke(msg.Character.ObjectIndex, RedrawType.AfterGPose);
+        });
+
+        Mediator.Subscribe<DalamudLoginMessage>(this, (msg) => _shownPenumbraUnavailable = false);
+    }
+
+    public bool APIAvailable { get; private set; } = false;
+
+    public void CheckAPI()
+    {
+        bool penumbraAvailable = false;
+        try
+        {
+            penumbraAvailable = _pluginLoaded && _pluginVersion >= new Version(1, 0, 1, 0);
+            try
+            {
+                penumbraAvailable &= _penumbraEnabled.Invoke();
+            }
+            catch
+            {
+                penumbraAvailable = false;
+            }
+            _shownPenumbraUnavailable = _shownPenumbraUnavailable && !penumbraAvailable;
+            APIAvailable = penumbraAvailable;
+        }
+        catch
+        {
+            APIAvailable = penumbraAvailable;
+        }
+        finally
+        {
+            if (!penumbraAvailable && !_shownPenumbraUnavailable)
+            {
+                _shownPenumbraUnavailable = true;
+                _mareMediator.Publish(new NotificationMessage("Penumbra inactive",
+                    "Your Penumbra installation is not active or out of date. Update Penumbra and/or the Enable Mods setting in Penumbra to continue to use Elezen. If you just updated Penumbra, ignore this message.",
+                    NotificationType.Error));
+            }
+        }
+    }
+
+    public void CheckModDirectory()
+    {
+        if (!APIAvailable)
+        {
+            ModDirectory = string.Empty;
+        }
+        else
+        {
+            ModDirectory = _penumbraResolveModDir!.Invoke().ToLowerInvariant();
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        _redrawManager.Cancel();
+
+        _penumbraModSettingChanged.Dispose();
+        _penumbraGameObjectResourcePathResolved.Dispose();
+        _penumbraDispose.Dispose();
+        _penumbraInit.Dispose();
+        _penumbraObjectIsRedrawn.Dispose();
+    }
+
+    public async Task AssignTemporaryCollectionAsync(ILogger logger, Guid collName, int idx)
+    {
+        if (!APIAvailable) return;
+
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var retAssign = _penumbraAssignTemporaryCollection.Invoke(collName, idx, forceAssignment: true);
+            logger.LogTrace("Assigning Temp Collection {collName} to index {idx}, Success: {ret}", collName, idx, retAssign);
+            return collName;
+        }).ConfigureAwait(false);
+    }
+
+    public async Task ConvertTextureFiles(ILogger logger, Dictionary<string, string[]> textures, IProgress<(string, int)> progress, CancellationToken token)
+    {
+        if (!APIAvailable) return;
+
+        _mareMediator.Publish(new HaltScanMessage(nameof(ConvertTextureFiles)));
+        int currentTexture = 0;
+        foreach (var texture in textures)
+        {
+            if (token.IsCancellationRequested) break;
+
+            progress.Report((texture.Key, ++currentTexture));
+
+            logger.LogInformation("Converting Texture {path} to {type}", texture.Key, TextureType.Bc7Tex);
+            var convertTask = _penumbraConvertTextureFile.Invoke(texture.Key, texture.Key, TextureType.Bc7Tex, mipMaps: true);
+            await convertTask.ConfigureAwait(false);
+            if (convertTask.IsCompletedSuccessfully && texture.Value.Any())
+            {
+                foreach (var duplicatedTexture in texture.Value)
+                {
+                    logger.LogInformation("Migrating duplicate {dup}", duplicatedTexture);
+                    try
+                    {
+                        File.Copy(texture.Key, duplicatedTexture, overwrite: true);
+                    }
+                    catch (Exception ex)
+                    {
+                        logger.LogError(ex, "Failed to copy duplicate {dup}", duplicatedTexture);
+                    }
+                }
+            }
+        }
+        _mareMediator.Publish(new ResumeScanMessage(nameof(ConvertTextureFiles)));
+
+        await _dalamudUtil.RunOnFrameworkThread(async () =>
+        {
+            var gameObject = await _dalamudUtil.CreateGameObjectAsync(await _dalamudUtil.GetPlayerPointerAsync().ConfigureAwait(false)).ConfigureAwait(false);
+            _penumbraRedraw.Invoke(gameObject!.ObjectIndex, setting: RedrawType.Redraw);
+        }).ConfigureAwait(false);
+    }
+
+    public async Task<Guid> CreateTemporaryCollectionAsync(ILogger logger, string uid)
+    {
+        if (!APIAvailable) return Guid.Empty;
+
+        return await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var collName = "ElfSync_" + uid;
+            var collId = _penumbraCreateNamedTemporaryCollection.Invoke(collName);
+            logger.LogTrace("Creating Temp Collection {collName}, GUID: {collId}", collName, collId);
+            return collId;
+
+        }).ConfigureAwait(false);
+    }
+
+    public async Task<Dictionary<string, HashSet<string>>?> GetCharacterData(ILogger logger, GameObjectHandler handler)
+    {
+        if (!APIAvailable) return null;
+
+        return await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            logger.LogTrace("Calling On IPC: Penumbra.GetGameObjectResourcePaths");
+            var idx = handler.GetGameObject()?.ObjectIndex;
+            if (idx == null) return null;
+            return _penumbraResourcePaths.Invoke(idx.Value)[0];
+        }).ConfigureAwait(false);
+    }
+
+    public string GetMetaManipulations()
+    {
+        if (!APIAvailable) return string.Empty;
+        return _penumbraGetMetaManipulations.Invoke();
+    }
+
+    public async Task RedrawAsync(ILogger logger, GameObjectHandler handler, Guid applicationId, CancellationToken token)
+    {
+        if (!APIAvailable || _dalamudUtil.IsZoning) return;
+        try
+        {
+            await _redrawManager.RedrawSemaphore.WaitAsync(token).ConfigureAwait(false);
+            await _redrawManager.PenumbraRedrawInternalAsync(logger, handler, applicationId, (chara) =>
+            {
+                logger.LogDebug("[{appid}] Calling on IPC: PenumbraRedraw", applicationId);
+                _penumbraRedraw!.Invoke(chara.ObjectIndex, setting: RedrawType.Redraw);
+
+            }, token).ConfigureAwait(false);
+        }
+        finally
+        {
+            _redrawManager.RedrawSemaphore.Release();
+        }
+    }
+
+    public void RedrawNow(ILogger logger, Guid applicationId, int objectIndex)
+    {
+        if (!APIAvailable || _dalamudUtil.IsZoning) return;
+        logger.LogTrace("[{applicationId}] Immediately redrawing object index {objId}", applicationId, objectIndex);
+        _penumbraRedraw.Invoke(objectIndex);
+    }
+
+    public async Task RemoveTemporaryCollectionAsync(ILogger logger, Guid applicationId, Guid collId)
+    {
+        if (!APIAvailable) return;
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            logger.LogTrace("[{applicationId}] Removing temp collection for {collId}", applicationId, collId);
+            var ret2 = _penumbraRemoveTemporaryCollection.Invoke(collId);
+            logger.LogTrace("[{applicationId}] RemoveTemporaryCollection: {ret2}", applicationId, ret2);
+        }).ConfigureAwait(false);
+    }
+
+    public async Task<(string[] forward, string[][] reverse)> ResolvePathsAsync(string[] forward, string[] reverse)
+    {
+        return await _penumbraResolvePaths.Invoke(forward, reverse).ConfigureAwait(false);
+    }
+
+    public async Task SetManipulationDataAsync(ILogger logger, Guid applicationId, Guid collId, string manipulationData)
+    {
+        if (!APIAvailable) return;
+
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            logger.LogTrace("[{applicationId}] Manip: {data}", applicationId, manipulationData);
+            var retAdd = _penumbraAddTemporaryMod.Invoke("MareChara_Meta", collId, [], manipulationData, 0);
+            logger.LogTrace("[{applicationId}] Setting temp meta mod for {collId}, Success: {ret}", applicationId, collId, retAdd);
+        }).ConfigureAwait(false);
+    }
+
+    public async Task SetTemporaryModsAsync(ILogger logger, Guid applicationId, Guid collId, Dictionary<string, string> modPaths)
+    {
+        if (!APIAvailable) return;
+
+        await _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            foreach (var mod in modPaths)
+            {
+                logger.LogTrace("[{applicationId}] Change: {from} => {to}", applicationId, mod.Key, mod.Value);
+            }
+            var retRemove = _penumbraRemoveTemporaryMod.Invoke("MareChara_Files", collId, 0);
+            logger.LogTrace("[{applicationId}] Removing temp files mod for {collId}, Success: {ret}", applicationId, collId, retRemove);
+            var retAdd = _penumbraAddTemporaryMod.Invoke("MareChara_Files", collId, modPaths, string.Empty, 0);
+            logger.LogTrace("[{applicationId}] Setting temp files mod for {collId}, Success: {ret}", applicationId, collId, retAdd);
+        }).ConfigureAwait(false);
+    }
+
+    private void RedrawEvent(IntPtr objectAddress, int objectTableIndex)
+    {
+        bool wasRequested = false;
+        if (_penumbraRedrawRequests.TryGetValue(objectAddress, out var redrawRequest) && redrawRequest)
+        {
+            _penumbraRedrawRequests[objectAddress] = false;
+        }
+        else
+        {
+            _mareMediator.Publish(new PenumbraRedrawMessage(objectAddress, objectTableIndex, wasRequested));
+        }
+    }
+
+    private void ResourceLoaded(IntPtr ptr, string arg1, string arg2)
+    {
+        if (ptr != IntPtr.Zero && string.Compare(arg1, arg2, ignoreCase: true, System.Globalization.CultureInfo.InvariantCulture) != 0)
+        {
+            _mareMediator.Publish(new PenumbraResourceLoadMessage(ptr, arg1, arg2));
+        }
+    }
+
+    private void PenumbraDispose()
+    {
+        _redrawManager.Cancel();
+        _mareMediator.Publish(new PenumbraDisposedMessage());
+    }
+
+    private void PenumbraInit()
+    {
+        APIAvailable = true;
+        ModDirectory = _penumbraResolveModDir.Invoke();
+        _mareMediator.Publish(new PenumbraInitializedMessage());
+        _penumbraRedraw!.Invoke(0, setting: RedrawType.Redraw);
+    }
+}

MareSynchronos/Interop/Ipc/IpcCallerPetNames.cs

@@ -0,0 +1,158 @@
+using Dalamud.Game.ClientState.Objects.SubKinds;
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed class IpcCallerPetNames : IIpcCaller
+{
+    private readonly ILogger<IpcCallerPetNames> _logger;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly MareMediator _mareMediator;
+
+    private readonly ICallGateSubscriber<object> _petnamesReady;
+    private readonly ICallGateSubscriber<object> _petnamesDisposing;
+    private readonly ICallGateSubscriber<(uint, uint)> _apiVersion;
+    private readonly ICallGateSubscriber<bool> _enabled;
+
+    private readonly ICallGateSubscriber<string, object> _playerDataChanged;
+    private readonly ICallGateSubscriber<string> _getPlayerData;
+    private readonly ICallGateSubscriber<string, object> _setPlayerData;
+    private readonly ICallGateSubscriber<ushort, object> _clearPlayerData;
+
+    public IpcCallerPetNames(ILogger<IpcCallerPetNames> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil,
+        MareMediator mareMediator)
+    {
+        _logger = logger;
+        _dalamudUtil = dalamudUtil;
+        _mareMediator = mareMediator;
+
+        _petnamesReady = pi.GetIpcSubscriber<object>("PetRenamer.Ready");
+        _petnamesDisposing = pi.GetIpcSubscriber<object>("PetRenamer.Disposing");
+        _apiVersion = pi.GetIpcSubscriber<(uint, uint)>("PetRenamer.ApiVersion");
+        _enabled = pi.GetIpcSubscriber<bool>("PetRenamer.Enabled");
+
+        _playerDataChanged = pi.GetIpcSubscriber<string, object>("PetRenamer.PlayerDataChanged");
+        _getPlayerData = pi.GetIpcSubscriber<string>("PetRenamer.GetPlayerData");
+        _setPlayerData = pi.GetIpcSubscriber<string, object>("PetRenamer.SetPlayerData");
+        _clearPlayerData = pi.GetIpcSubscriber<ushort, object>("PetRenamer.ClearPlayerData");
+
+        _petnamesReady.Subscribe(OnPetNicknamesReady);
+        _petnamesDisposing.Subscribe(OnPetNicknamesDispose);
+        _playerDataChanged.Subscribe(OnLocalPetNicknamesDataChange);
+
+        CheckAPI();
+    }
+
+    public bool APIAvailable { get; private set; } = false;
+
+    public void CheckAPI()
+    {
+        try
+        {
+            APIAvailable = _enabled?.InvokeFunc() ?? false;
+            if (APIAvailable)
+            {
+                APIAvailable = _apiVersion?.InvokeFunc() is { Item1: 3, Item2: >= 1 };
+            }
+        }
+        catch
+        {
+            APIAvailable = false;
+        }
+    }
+
+    private void OnPetNicknamesReady()
+    {
+        CheckAPI();
+        _mareMediator.Publish(new PetNamesReadyMessage());
+    }
+
+    private void OnPetNicknamesDispose()
+    {
+        _mareMediator.Publish(new PetNamesMessage(string.Empty));
+    }
+
+    public string GetLocalNames()
+    {
+        if (!APIAvailable) return string.Empty;
+
+        try
+        {
+            string localNameData = _getPlayerData.InvokeFunc();
+            return string.IsNullOrEmpty(localNameData) ? string.Empty : localNameData;
+        } 
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Could not obtain Pet Nicknames data");
+        }
+
+        return string.Empty;
+    }
+
+    public async Task SetPlayerData(nint character, string playerData)
+    {
+        if (!APIAvailable) return;
+
+        _logger.LogTrace("Applying Pet Nicknames data to {chara}", character.ToString("X"));
+
+        try
+        {
+            await _dalamudUtil.RunOnFrameworkThread(() =>
+            {
+                if (string.IsNullOrEmpty(playerData))
+                {
+                    var gameObj = _dalamudUtil.CreateGameObject(character);
+                    if (gameObj is IPlayerCharacter pc)
+                    {
+                        _clearPlayerData.InvokeAction(pc.ObjectIndex);
+                    }
+                }
+                else
+                {
+                    _setPlayerData.InvokeAction(playerData);
+                }
+            }).ConfigureAwait(false);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Could not apply Pet Nicknames data");
+        }
+    }
+
+    public async Task ClearPlayerData(nint characterPointer)
+    {
+        if (!APIAvailable) return;
+        try
+        {
+            await _dalamudUtil.RunOnFrameworkThread(() =>
+            {
+                var gameObj = _dalamudUtil.CreateGameObject(characterPointer);
+                if (gameObj is IPlayerCharacter pc)
+                {
+                    _logger.LogTrace("Pet Nicknames removing for {addr}", pc.Address.ToString("X"));
+                    _clearPlayerData.InvokeAction(pc.ObjectIndex);
+                }
+            }).ConfigureAwait(false);
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Could not clear Pet Nicknames data");
+        }
+    }
+
+    private void OnLocalPetNicknamesDataChange(string data)
+    {
+        _mareMediator.Publish(new PetNamesMessage(data));
+    }
+
+    public void Dispose()
+    {
+        _petnamesReady.Unsubscribe(OnPetNicknamesReady);
+        _petnamesDisposing.Unsubscribe(OnPetNicknamesDispose);
+        _playerDataChanged.Unsubscribe(OnLocalPetNicknamesDataChange);
+    }
+}

MareSynchronos/Interop/Ipc/IpcManager.cs

@@ -0,0 +1,68 @@
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public sealed partial class IpcManager : DisposableMediatorSubscriberBase
+{
+    public IpcManager(ILogger<IpcManager> logger, MareMediator mediator,
+        IpcCallerPenumbra penumbraIpc, IpcCallerGlamourer glamourerIpc, IpcCallerCustomize customizeIpc, IpcCallerHeels heelsIpc,
+        IpcCallerHonorific honorificIpc, IpcCallerMoodles moodlesIpc, IpcCallerPetNames ipcCallerPetNames, IpcCallerBrio ipcCallerBrio) : base(logger, mediator)
+    {
+        CustomizePlus = customizeIpc;
+        Heels = heelsIpc;
+        Glamourer = glamourerIpc;
+        Penumbra = penumbraIpc;
+        Honorific = honorificIpc;
+        Moodles = moodlesIpc;
+        PetNames = ipcCallerPetNames;
+        Brio = ipcCallerBrio;
+
+        if (Initialized)
+        {
+            Mediator.Publish(new PenumbraInitializedMessage());
+        }
+
+        Mediator.Subscribe<DelayedFrameworkUpdateMessage>(this, (_) => PeriodicApiStateCheck());
+
+        try
+        {
+            PeriodicApiStateCheck();
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Failed to check for some IPC, plugin not installed?");
+        }
+    }
+
+    public bool Initialized => Penumbra.APIAvailable && Glamourer.APIAvailable;
+
+    public IpcCallerCustomize CustomizePlus { get; init; }
+    public IpcCallerHonorific Honorific { get; init; }
+    public IpcCallerHeels Heels { get; init; }
+    public IpcCallerGlamourer Glamourer { get; }
+    public IpcCallerPenumbra Penumbra { get; }
+    public IpcCallerMoodles Moodles { get; }
+    public IpcCallerPetNames PetNames { get; }
+
+    public IpcCallerBrio Brio { get; }
+
+    private int _stateCheckCounter = -1;
+
+    private void PeriodicApiStateCheck()
+    {
+        // Stagger API checks
+        if (++_stateCheckCounter > 8)
+            _stateCheckCounter = 0;
+        int i = _stateCheckCounter;
+        if (i == 0) Penumbra.CheckAPI();
+        if (i == 1) Penumbra.CheckModDirectory();
+        if (i == 2) Glamourer.CheckAPI();
+        if (i == 3) Heels.CheckAPI();
+        if (i == 4) CustomizePlus.CheckAPI();
+        if (i == 5) Honorific.CheckAPI();
+        if (i == 6) Moodles.CheckAPI();
+        if (i == 7) PetNames.CheckAPI();
+        if (i == 8) Brio.CheckAPI();
+    }
+}

MareSynchronos/Interop/Ipc/IpcProvider.cs

@@ -0,0 +1,196 @@
+using Dalamud.Game.ClientState.Objects.Types;
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public class IpcProvider : IHostedService, IMediatorSubscriber
+{
+    private readonly ILogger<IpcProvider> _logger;
+    private readonly IDalamudPluginInterface _pi;
+    private readonly MareConfigService _mareConfig;
+    private readonly CharaDataManager _charaDataManager;
+    private ICallGateProvider<string, IGameObject, bool>? _loadFileProvider;
+    private ICallGateProvider<string, IGameObject, Task<bool>>? _loadFileAsyncProvider;
+    private ICallGateProvider<List<nint>>? _handledGameAddresses;
+    private readonly List<GameObjectHandler> _activeGameObjectHandlers = [];
+
+    private ICallGateProvider<string, IGameObject, bool>? _loadFileProviderMare;
+    private ICallGateProvider<string, IGameObject, Task<bool>>? _loadFileAsyncProviderMare;
+    private ICallGateProvider<List<nint>>? _handledGameAddressesMare;
+
+    private bool _marePluginEnabled = false;
+    private bool _impersonating = false;
+    private DateTime _unregisterTime = DateTime.UtcNow;
+    private CancellationTokenSource _registerDelayCts = new();
+
+    public bool MarePluginEnabled => _marePluginEnabled;
+    public bool ImpersonationActive => _impersonating;
+
+    public MareMediator Mediator { get; init; }
+
+    public IpcProvider(ILogger<IpcProvider> logger, IDalamudPluginInterface pi, MareConfigService mareConfig,
+        CharaDataManager charaDataManager, MareMediator mareMediator)
+    {
+        _logger = logger;
+        _pi = pi;
+        _mareConfig = mareConfig;
+        _charaDataManager = charaDataManager;
+        Mediator = mareMediator;
+
+        Mediator.Subscribe<GameObjectHandlerCreatedMessage>(this, (msg) =>
+        {
+            if (msg.OwnedObject) return;
+            _activeGameObjectHandlers.Add(msg.GameObjectHandler);
+        });
+        Mediator.Subscribe<GameObjectHandlerDestroyedMessage>(this, (msg) =>
+        {
+            if (msg.OwnedObject) return;
+            _activeGameObjectHandlers.Remove(msg.GameObjectHandler);
+        });
+
+        _marePluginEnabled = PluginWatcherService.GetInitialPluginState(pi, "MareSynchronos")?.IsLoaded ?? false;
+        Mediator.SubscribeKeyed<PluginChangeMessage>(this, "MareSynchronos", p => {
+            _marePluginEnabled = p.IsLoaded;
+            HandleMareImpersonation(automatic: true);
+        });
+    }
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogDebug("Starting IpcProvider Service");
+        _loadFileProvider = _pi.GetIpcProvider<string, IGameObject, bool>("ElfSync.LoadMcdf");
+        _loadFileProvider.RegisterFunc(LoadMcdf);
+        _loadFileAsyncProvider = _pi.GetIpcProvider<string, IGameObject, Task<bool>>("ElezenSync.LoadMcdfAsync");
+        _loadFileAsyncProvider.RegisterFunc(LoadMcdfAsync);
+        _handledGameAddresses = _pi.GetIpcProvider<List<nint>>("ElezenSync.GetHandledAddresses");
+        _handledGameAddresses.RegisterFunc(GetHandledAddresses);
+
+        _loadFileProviderMare = _pi.GetIpcProvider<string, IGameObject, bool>("MareSynchronos.LoadMcdf");
+        _loadFileAsyncProviderMare = _pi.GetIpcProvider<string, IGameObject, Task<bool>>("MareSynchronos.LoadMcdfAsync");
+        _handledGameAddressesMare = _pi.GetIpcProvider<List<nint>>("MareSynchronos.GetHandledAddresses");
+        HandleMareImpersonation(automatic: true);
+
+        _logger.LogInformation("Started IpcProviderService");
+        return Task.CompletedTask;
+    }
+
+    public void HandleMareImpersonation(bool automatic = false)
+    {
+        if (_marePluginEnabled)
+        {
+            if (_impersonating)
+            {
+                _loadFileProviderMare?.UnregisterFunc();
+                _loadFileAsyncProviderMare?.UnregisterFunc();
+                _handledGameAddressesMare?.UnregisterFunc();
+                _impersonating = false;
+                _unregisterTime = DateTime.UtcNow;
+                _logger.LogDebug("Unregistered MareSynchronos API");
+            }
+        }
+        else
+        {
+            if (_mareConfig.Current.MareAPI)
+            {
+                var cancelToken = _registerDelayCts.Token;
+                Task.Run(async () =>
+                {
+                    // Wait before registering to reduce the chance of a race condition
+                    if (automatic)
+                        await Task.Delay(5000);
+
+                    if (cancelToken.IsCancellationRequested)
+                        return;
+
+                    if (_marePluginEnabled)
+                    {
+                        _logger.LogDebug("Not registering MareSynchronos API: Mare plugin is loaded");
+                        return;
+                    }
+
+                    _loadFileProviderMare?.RegisterFunc(LoadMcdf);
+                    _loadFileAsyncProviderMare?.RegisterFunc(LoadMcdfAsync);
+                    _handledGameAddressesMare?.RegisterFunc(GetHandledAddresses);
+                    _impersonating = true;
+                    _logger.LogDebug("Registered MareSynchronos API");
+                }, cancelToken);
+            }
+            else
+            {
+                _registerDelayCts = _registerDelayCts.CancelRecreate();
+                if (_impersonating)
+                {
+                    _loadFileProviderMare?.UnregisterFunc();
+                    _loadFileAsyncProviderMare?.UnregisterFunc();
+                    _handledGameAddressesMare?.UnregisterFunc();
+                    _impersonating = false;
+                    _unregisterTime = DateTime.UtcNow;
+                    _logger.LogDebug("Unregistered MareSynchronos API");
+                }
+            }
+        }
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        _logger.LogDebug("Stopping IpcProvider Service");
+        _loadFileProvider?.UnregisterFunc();
+        _loadFileAsyncProvider?.UnregisterFunc();
+        _handledGameAddresses?.UnregisterFunc();
+
+        _registerDelayCts.Cancel();
+        if (_impersonating)
+        {
+            _loadFileProviderMare?.UnregisterFunc();
+            _loadFileAsyncProviderMare?.UnregisterFunc();
+            _handledGameAddressesMare?.UnregisterFunc();
+        }
+
+        Mediator.UnsubscribeAll(this);
+        return Task.CompletedTask;
+    }
+
+    private async Task<bool> LoadMcdfAsync(string path, IGameObject target)
+    {
+        await ApplyFileAsync(path, target).ConfigureAwait(false);
+
+        return true;
+    }
+
+    private bool LoadMcdf(string path, IGameObject target)
+    {
+        _ = Task.Run(async () => await ApplyFileAsync(path, target).ConfigureAwait(false)).ConfigureAwait(false);
+
+        return true;
+    }
+
+    private async Task ApplyFileAsync(string path, IGameObject target)
+    {
+        _charaDataManager.LoadMcdf(path);
+        await (_charaDataManager.LoadedMcdfHeader ?? Task.CompletedTask).ConfigureAwait(false);
+        _charaDataManager.McdfApplyToTarget(target.Name.TextValue);
+    }
+
+    private List<nint> GetHandledAddresses()
+    {
+        if (!_impersonating)
+        {
+            if ((DateTime.UtcNow - _unregisterTime).TotalSeconds >= 1.0)
+            {
+                _logger.LogWarning("GetHandledAddresses called when it should not be registered");
+                _handledGameAddressesMare?.UnregisterFunc();
+            }
+            return [];
+        }
+
+        return _activeGameObjectHandlers.Where(g => g.Address != nint.Zero).Select(g => g.Address).Distinct().ToList();
+    }
+}

MareSynchronos/Interop/Ipc/RedrawManager.cs

@@ -0,0 +1,54 @@
+using Dalamud.Game.ClientState.Objects.Types;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+
+namespace MareSynchronos.Interop.Ipc;
+
+public class RedrawManager
+{
+    private readonly MareMediator _mareMediator;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly ConcurrentDictionary<nint, bool> _penumbraRedrawRequests = [];
+    private CancellationTokenSource _disposalCts = new();
+
+    public SemaphoreSlim RedrawSemaphore { get; init; } = new(2, 2);
+
+    public RedrawManager(MareMediator mareMediator, DalamudUtilService dalamudUtil)
+    {
+        _mareMediator = mareMediator;
+        _dalamudUtil = dalamudUtil;
+    }
+
+    public async Task PenumbraRedrawInternalAsync(ILogger logger, GameObjectHandler handler, Guid applicationId, Action<ICharacter> action, CancellationToken token)
+    {
+        _mareMediator.Publish(new PenumbraStartRedrawMessage(handler.Address));
+
+        _penumbraRedrawRequests[handler.Address] = true;
+
+        try
+        {
+            using CancellationTokenSource cancelToken = new CancellationTokenSource();
+            using CancellationTokenSource combinedCts = CancellationTokenSource.CreateLinkedTokenSource(cancelToken.Token, token, _disposalCts.Token);
+            var combinedToken = combinedCts.Token;
+            cancelToken.CancelAfter(TimeSpan.FromSeconds(15));
+            await handler.ActOnFrameworkAfterEnsureNoDrawAsync(action, combinedToken).ConfigureAwait(false);
+
+            if (!_disposalCts.Token.IsCancellationRequested)
+                await _dalamudUtil.WaitWhileCharacterIsDrawing(logger, handler, applicationId, 30000, combinedToken).ConfigureAwait(false);
+        }
+        finally
+        {
+            _penumbraRedrawRequests[handler.Address] = false;
+            _mareMediator.Publish(new PenumbraEndRedrawMessage(handler.Address));
+        }
+    }
+
+    internal void Cancel()
+    {
+        _disposalCts = _disposalCts.CancelRecreate();
+    }
+}

MareSynchronos/Interop/VfxSpawnManager.cs

@@ -0,0 +1,203 @@
+using Dalamud.Memory;
+using Dalamud.Plugin.Services;
+using Dalamud.Utility.Signatures;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace MareSynchronos.Interop;
+
+/// <summary>
+/// Code for spawning mostly taken from https://git.anna.lgbt/anna/OrangeGuidanceTomestone/src/branch/main/client/Vfx.cs
+/// </summary>
+public unsafe class VfxSpawnManager : DisposableMediatorSubscriberBase
+{
+    private static readonly byte[] _pool = "Client.System.Scheduler.Instance.VfxObject\0"u8.ToArray();
+
+    #region signatures
+    #pragma warning disable CS0649
+    [Signature("E8 ?? ?? ?? ?? F3 0F 10 35 ?? ?? ?? ?? 48 89 43 08")]
+    private readonly delegate* unmanaged<byte*, byte*, VfxStruct*> _staticVfxCreate;
+
+    [Signature("E8 ?? ?? ?? ?? ?? ?? ?? 8B 4A ?? 85 C9")]
+    private readonly delegate* unmanaged<VfxStruct*, float, int, ulong> _staticVfxRun;
+
+    [Signature("40 53 48 83 EC 20 48 8B D9 48 8B 89 ?? ?? ?? ?? 48 85 C9 74 28 33 D2 E8 ?? ?? ?? ?? 48 8B 8B ?? ?? ?? ?? 48 85 C9")]
+    private readonly delegate* unmanaged<VfxStruct*, nint> _staticVfxRemove;
+    #pragma warning restore CS0649
+    #endregion
+
+    public VfxSpawnManager(ILogger<VfxSpawnManager> logger, IGameInteropProvider gameInteropProvider, MareMediator mareMediator)
+        : base(logger, mareMediator)
+    {
+        gameInteropProvider.InitializeFromAttributes(this);
+        mareMediator.Subscribe<GposeStartMessage>(this, (msg) =>
+        {
+            ChangeSpawnVisibility(0f);
+        });
+        mareMediator.Subscribe<GposeEndMessage>(this, (msg) =>
+        {
+            RestoreSpawnVisiblity();
+        });
+        mareMediator.Subscribe<CutsceneStartMessage>(this, (msg) =>
+        {
+            ChangeSpawnVisibility(0f);
+        });
+        mareMediator.Subscribe<CutsceneEndMessage>(this, (msg) =>
+        {
+            RestoreSpawnVisiblity();
+        });
+    }
+
+    private unsafe void RestoreSpawnVisiblity()
+    {
+        foreach (var vfx in _spawnedObjects)
+        {
+            ((VfxStruct*)vfx.Value.Address)->Alpha = vfx.Value.Visibility;
+        }
+    }
+
+    private unsafe void ChangeSpawnVisibility(float visibility)
+    {
+        foreach (var vfx in _spawnedObjects)
+        {
+            ((VfxStruct*)vfx.Value.Address)->Alpha = visibility;
+        }
+    }
+
+    private readonly Dictionary<Guid, (nint Address, float Visibility)> _spawnedObjects = [];
+
+    private VfxStruct* SpawnStatic(string path, Vector3 pos, Quaternion rotation, float r, float g, float b, float a, Vector3 scale)
+    {
+        VfxStruct* vfx;
+        fixed (byte* terminatedPath = Encoding.UTF8.GetBytes(path).NullTerminate())
+        {
+            fixed (byte* pool = _pool)
+            {
+                vfx = _staticVfxCreate(terminatedPath, pool);
+            }
+        }
+
+        if (vfx == null)
+        {
+            return null;
+        }
+
+        vfx->Position = new Vector3(pos.X, pos.Y + 1, pos.Z);
+        vfx->Rotation = new Quaternion(rotation.X, rotation.Y, rotation.Z, rotation.W);
+
+        vfx->SomeFlags &= 0xF7;
+        vfx->Flags |= 2;
+        vfx->Red = r;
+        vfx->Green = g;
+        vfx->Blue = b;
+        vfx->Scale = scale;
+
+        vfx->Alpha = a;
+
+        _staticVfxRun(vfx, 0.0f, -1);
+
+        return vfx;
+    }
+
+    public Guid? SpawnObject(Vector3 position, Quaternion rotation, Vector3 scale, float r = 1f, float g = 1f, float b = 1f, float a = 0.5f)
+    {
+        Logger.LogDebug("Trying to Spawn orb VFX at {pos}, {rot}", position, rotation);
+        var vfx = SpawnStatic("bgcommon/world/common/vfx_for_event/eff/b0150_eext_y.avfx", position, rotation, r, g, b, a, scale);
+        if (vfx == null || (nint)vfx == nint.Zero)
+        {
+            Logger.LogDebug("Failed to Spawn VFX at {pos}, {rot}", position, rotation);
+            return null;
+        }
+        Guid guid = Guid.NewGuid();
+        Logger.LogDebug("Spawned VFX at {pos}, {rot}: 0x{ptr:X}", position, rotation, (nint)vfx);
+
+        _spawnedObjects[guid] = ((nint)vfx, a);
+
+        return guid;
+    }
+
+    public unsafe void MoveObject(Guid id, Vector3 newPosition)
+    {
+        if (_spawnedObjects.TryGetValue(id, out var vfxValue))
+        {
+            if (vfxValue.Address == nint.Zero) return;
+            var vfx = (VfxStruct*)vfxValue.Address;
+            vfx->Position = newPosition with { Y = newPosition.Y + 1 };
+            vfx->Flags |= 2;
+        }
+    }
+
+    public void DespawnObject(Guid? id)
+    {
+        if (id == null) return;
+        if (_spawnedObjects.Remove(id.Value, out var value))
+        {
+            Logger.LogDebug("Despawning {obj:X}", value.Address);
+            _staticVfxRemove((VfxStruct*)value.Address);
+        }
+    }
+
+    private void RemoveAllVfx()
+    {
+        foreach (var obj in _spawnedObjects.Values)
+        {
+            Logger.LogDebug("Despawning {obj:X}", obj);
+            _staticVfxRemove((VfxStruct*)obj.Address);
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        if (disposing)
+        {
+            RemoveAllVfx();
+        }
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    internal struct VfxStruct
+    {
+        [FieldOffset(0x38)]
+        public byte Flags;
+
+        [FieldOffset(0x50)]
+        public Vector3 Position;
+
+        [FieldOffset(0x60)]
+        public Quaternion Rotation;
+
+        [FieldOffset(0x70)]
+        public Vector3 Scale;
+
+        [FieldOffset(0x128)]
+        public int ActorCaster;
+
+        [FieldOffset(0x130)]
+        public int ActorTarget;
+
+        [FieldOffset(0x1B8)]
+        public int StaticCaster;
+
+        [FieldOffset(0x1C0)]
+        public int StaticTarget;
+
+        [FieldOffset(0x248)]
+        public byte SomeFlags;
+
+        [FieldOffset(0x260)]
+        public float Red;
+
+        [FieldOffset(0x264)]
+        public float Green;
+
+        [FieldOffset(0x268)]
+        public float Blue;
+
+        [FieldOffset(0x26C)]
+        public float Alpha;
+    }
+}

MareSynchronos/MareConfiguration/CharaDataConfigService.cs

@@ -0,0 +1,11 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class CharaDataConfigService : ConfigurationServiceBase<CharaDataConfig>
+{
+    public const string ConfigName = "charadata.json";
+
+    public CharaDataConfigService(string configDir) : base(configDir) { }
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/ConfigurationExtensions.cs

@@ -0,0 +1,13 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public static class ConfigurationExtensions
+{
+    public static bool HasValidSetup(this MareConfig configuration)
+    {
+        return configuration.AcceptedAgreement && configuration.InitialScanComplete
+                    && !string.IsNullOrEmpty(configuration.CacheFolder)
+                    && Directory.Exists(configuration.CacheFolder);
+    }
+}

MareSynchronos/MareConfiguration/ConfigurationMigrator.cs

@@ -0,0 +1,25 @@
+using MareSynchronos.WebAPI;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class ConfigurationMigrator(ILogger<ConfigurationMigrator> logger) : IHostedService
+{
+    private readonly ILogger<ConfigurationMigrator> _logger = logger;
+
+    public void Migrate()
+    {
+    }
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        Migrate();
+        return Task.CompletedTask;
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        return Task.CompletedTask;
+    }
+}

MareSynchronos/MareConfiguration/ConfigurationSaveService.cs

@@ -0,0 +1,137 @@
+using MareSynchronos.MareConfiguration.Configurations;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System.Reflection;
+using System.Text.Json;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class ConfigurationSaveService : IHostedService
+{
+    private readonly HashSet<object> _configsToSave = [];
+    private readonly ILogger<ConfigurationSaveService> _logger;
+    private readonly SemaphoreSlim _configSaveSemaphore = new(1, 1);
+    private readonly CancellationTokenSource _configSaveCheckCts = new();
+    public const string BackupFolder = "config_backup";
+    private readonly MethodInfo _saveMethod;
+
+    public ConfigurationSaveService(ILogger<ConfigurationSaveService> logger, IEnumerable<IConfigService<IMareConfiguration>> configs)
+    {
+        foreach (var config in configs)
+        {
+            config.ConfigSave += OnConfigurationSave;
+        }
+        _logger = logger;
+#pragma warning disable S3011 // Reflection should not be used to increase accessibility of classes, methods, or fields
+        _saveMethod = GetType().GetMethod(nameof(SaveConfig), BindingFlags.Instance | BindingFlags.NonPublic)!;
+#pragma warning restore S3011 // Reflection should not be used to increase accessibility of classes, methods, or fields
+    }
+
+    private void OnConfigurationSave(object? sender, EventArgs e)
+    {
+        _configSaveSemaphore.Wait();
+        _configsToSave.Add(sender!);
+        _configSaveSemaphore.Release();
+    }
+
+    private async Task PeriodicSaveCheck(CancellationToken ct)
+    {
+        while (!ct.IsCancellationRequested)
+        {
+            try
+            {
+                await SaveConfigs().ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error during SaveConfigs");
+            }
+
+            await Task.Delay(TimeSpan.FromSeconds(5), ct).ConfigureAwait(false);
+        }
+    }
+
+    private async Task SaveConfigs()
+    {
+        if (_configsToSave.Count == 0) return;
+
+        await _configSaveSemaphore.WaitAsync().ConfigureAwait(false);
+        var configList = _configsToSave.ToList();
+        _configsToSave.Clear();
+        _configSaveSemaphore.Release();
+
+        foreach (var config in configList)
+        {
+            var expectedType = config.GetType().BaseType!.GetGenericArguments()[0];
+            var save = _saveMethod.MakeGenericMethod(expectedType);
+            await ((Task)save.Invoke(this, [config])!).ConfigureAwait(false);
+        }
+    }
+
+    private async Task SaveConfig<T>(IConfigService<T> config) where T : IMareConfiguration
+    {
+        _logger.LogTrace("Saving {configName}", config.ConfigurationName);
+        var configDir = config.ConfigurationPath.Replace(config.ConfigurationName, string.Empty);
+
+        try
+        {
+            var configBackupFolder = Path.Join(configDir, BackupFolder);
+            if (!Directory.Exists(configBackupFolder))
+                Directory.CreateDirectory(configBackupFolder);
+
+            var configNameSplit = config.ConfigurationName.Split(".");
+            var existingConfigs = Directory.EnumerateFiles(
+                configBackupFolder,
+                configNameSplit[0] + "*")
+                .Select(c => new FileInfo(c))
+                .OrderByDescending(c => c.LastWriteTime).ToList();
+            if (existingConfigs.Skip(10).Any())
+            {
+                foreach (var oldBak in existingConfigs.Skip(10).ToList())
+                {
+                    oldBak.Delete();
+                }
+            }
+
+            string backupPath = Path.Combine(configBackupFolder, configNameSplit[0] + "." + DateTime.Now.ToString("yyyyMMddHHmmss") + "." + configNameSplit[1]);
+            _logger.LogTrace("Backing up current config to {backupPath}", backupPath);
+            File.Copy(config.ConfigurationPath, backupPath, overwrite: true);
+            FileInfo fi = new(backupPath);
+            fi.LastWriteTimeUtc = DateTime.UtcNow;
+        }
+        catch (Exception ex)
+        {
+            // ignore if file cannot be backupped
+            _logger.LogWarning(ex, "Could not create backup for {config}", config.ConfigurationPath);
+        }
+
+        var temp = config.ConfigurationPath + ".tmp";
+        try
+        {
+            await File.WriteAllTextAsync(temp, JsonSerializer.Serialize(config.Current, typeof(T), new JsonSerializerOptions()
+            {
+                WriteIndented = true
+            })).ConfigureAwait(false);
+            File.Move(temp, config.ConfigurationPath, true);
+            config.UpdateLastWriteTime();
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Error during config save of {config}", config.ConfigurationName);
+        }
+    }
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        _ = Task.Run(() => PeriodicSaveCheck(_configSaveCheckCts.Token));
+        return Task.CompletedTask;
+    }
+
+    public async Task StopAsync(CancellationToken cancellationToken)
+    {
+        await _configSaveCheckCts.CancelAsync().ConfigureAwait(false);
+        _configSaveCheckCts.Dispose();
+
+        await SaveConfigs().ConfigureAwait(false);
+    }
+}

MareSynchronos/MareConfiguration/ConfigurationServiceBase.cs

@@ -0,0 +1,141 @@
+using MareSynchronos.MareConfiguration.Configurations;
+using System.Text.Json;
+
+namespace MareSynchronos.MareConfiguration;
+
+public abstract class ConfigurationServiceBase<T> : IConfigService<T> where T : IMareConfiguration
+{
+    private readonly CancellationTokenSource _periodicCheckCts = new();
+    private DateTime _configLastWriteTime;
+    private Lazy<T> _currentConfigInternal;
+    private bool _disposed = false;
+
+    public event EventHandler? ConfigSave;
+
+    protected ConfigurationServiceBase(string configDirectory)
+    {
+        ConfigurationDirectory = configDirectory;
+
+        _ = Task.Run(CheckForConfigUpdatesInternal, _periodicCheckCts.Token);
+
+        _currentConfigInternal = LazyConfig();
+    }
+
+    public string ConfigurationDirectory { get; init; }
+    public T Current => _currentConfigInternal.Value;
+    public abstract string ConfigurationName { get; }
+    public string ConfigurationPath => Path.Combine(ConfigurationDirectory, ConfigurationName);
+
+    public void Dispose()
+    {
+        Dispose(disposing: true);
+        GC.SuppressFinalize(this);
+    }
+
+    public void Save()
+    {
+        ConfigSave?.Invoke(this, EventArgs.Empty);
+    }
+
+    public void UpdateLastWriteTime()
+    {
+        _configLastWriteTime = GetConfigLastWriteTime();
+    }
+
+    protected virtual void Dispose(bool disposing)
+    {
+        if (!disposing || _disposed) return;
+        _disposed = true;
+        _periodicCheckCts.Cancel();
+        _periodicCheckCts.Dispose();
+    }
+
+    protected T LoadConfig()
+    {
+        T? config;
+        if (!File.Exists(ConfigurationPath))
+        {
+            config = AttemptToLoadBackup();
+        }
+        else
+        {
+            try
+            {
+                config = JsonSerializer.Deserialize<T>(File.ReadAllText(ConfigurationPath));
+            }
+            catch
+            {
+                // config failed to load for some reason
+                config = AttemptToLoadBackup();
+            }
+        }
+
+        if (config == null || Equals(config, default(T)))
+        {
+            config = Activator.CreateInstance<T>();
+            Save();
+        }
+
+        _configLastWriteTime = GetConfigLastWriteTime();
+        return config;
+    }
+
+    private T? AttemptToLoadBackup()
+    {
+        var configBackupFolder = Path.Join(ConfigurationDirectory, ConfigurationSaveService.BackupFolder);
+        var configNameSplit = ConfigurationName.Split(".");
+        if (!Directory.Exists(configBackupFolder))
+            return default;
+
+        var existingBackups = Directory.EnumerateFiles(configBackupFolder, configNameSplit[0] + "*").OrderByDescending(f => new FileInfo(f).LastWriteTimeUtc);
+        foreach (var file in existingBackups)
+        {
+            try
+            {
+                var config = JsonSerializer.Deserialize<T>(File.ReadAllText(file));
+                if (Equals(config, default(T)))
+                {
+                    File.Delete(file);
+                }
+
+                File.Copy(file, ConfigurationPath, true);
+                return config;
+            }
+            catch
+            {
+                // couldn't load backup, might as well delete it
+                File.Delete(file);
+            }
+
+        }
+
+        return default;
+    }
+
+    private async Task CheckForConfigUpdatesInternal()
+    {
+        while (!_periodicCheckCts.IsCancellationRequested)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(5), _periodicCheckCts.Token).ConfigureAwait(false);
+
+            var lastWriteTime = GetConfigLastWriteTime();
+            if (lastWriteTime != _configLastWriteTime)
+            {
+                _currentConfigInternal = LazyConfig();
+            }
+        }
+    }
+
+    private DateTime GetConfigLastWriteTime()
+    {
+        try { return new FileInfo(ConfigurationPath).LastWriteTimeUtc; }
+        catch { return DateTime.MinValue; }
+    }
+
+
+    private Lazy<T> LazyConfig()
+    {
+        _configLastWriteTime = GetConfigLastWriteTime();
+        return new Lazy<T>(LoadConfig);
+    }
+}

MareSynchronos/MareConfiguration/Configurations/CharaDataConfig.cs

@@ -0,0 +1,19 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public class CharaDataConfig : IMareConfiguration
+{
+    public bool OpenMareHubOnGposeStart { get; set; } = false;
+    public string LastSavedCharaDataLocation { get; set; } = string.Empty;
+    public Dictionary<string, CharaDataFavorite> FavoriteCodes { get; set; } = [];
+    public bool DownloadMcdDataOnConnection { get; set; } = true;
+    public int Version { get; set; } = 0;
+    public bool NearbyOwnServerOnly { get; set; } = false;
+    public bool NearbyIgnoreHousingLimitations { get; set; } = false;
+    public bool NearbyDrawWisps { get; set; } = true;
+    public int NearbyDistanceFilter { get; set; } = 100;
+    public bool NearbyShowOwnData { get; set; } = false;
+    public bool ShowHelpTexts { get; set; } = true;
+    public bool NearbyShowAlways { get; set; } = false;
+}

MareSynchronos/MareConfiguration/Configurations/IMareConfiguration.cs

@@ -0,0 +1,6 @@
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public interface IMareConfiguration
+{
+    int Version { get; set; }
+}

MareSynchronos/MareConfiguration/Configurations/MareConfig.cs

@@ -0,0 +1,76 @@
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.UI;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+[Serializable]
+public class MareConfig : IMareConfiguration
+{
+    public bool AcceptedAgreement { get; set; } = false;
+    public string CacheFolder { get; set; } = string.Empty;
+    public bool DisableOptionalPluginWarnings { get; set; } = false;
+    public bool EnableDtrEntry { get; set; } = true;
+    public int DtrStyle { get; set; } = 0;
+    public bool ShowUidInDtrTooltip { get; set; } = true;
+    public bool PreferNoteInDtrTooltip { get; set; } = false;
+    public bool UseColorsInDtr { get; set; } = true;
+    public DtrEntry.Colors DtrColorsDefault { get; set; } = default;
+    public DtrEntry.Colors DtrColorsNotConnected { get; set; } = new(Glow: 0x0428FFu);
+    public DtrEntry.Colors DtrColorsPairsInRange { get; set; } = new(Glow: 0xFFBA47u);
+    public bool UseNameColors { get; set; } = false;
+    public DtrEntry.Colors NameColors { get; set; } = new(Foreground: 0x67EBF5u, Glow: 0x00303Cu);
+    public DtrEntry.Colors BlockedNameColors { get; set; } = new(Foreground: 0x8AADC7, Glow: 0x000080u);
+    public bool EnableRightClickMenus { get; set; } = true;
+    public NotificationLocation ErrorNotification { get; set; } = NotificationLocation.Both;
+    public string ExportFolder { get; set; } = string.Empty;
+    public bool FileScanPaused { get; set; } = false;
+    public NotificationLocation InfoNotification { get; set; } = NotificationLocation.Toast;
+    public bool InitialScanComplete { get; set; } = false;
+    public LogLevel LogLevel { get; set; } = LogLevel.Information;
+    public bool LogPerformance { get; set; } = false;
+    public bool LogEvents { get; set; } = true;
+    public bool HoldCombatApplication { get; set; } = false;
+    public double MaxLocalCacheInGiB { get; set; } = 20;
+    public bool OpenGposeImportOnGposeStart { get; set; } = false;
+    public bool OpenPopupOnAdd { get; set; } = true;
+    public int ParallelDownloads { get; set; } = 10;
+    public int DownloadSpeedLimitInBytes { get; set; } = 0;
+    public DownloadSpeeds DownloadSpeedType { get; set; } = DownloadSpeeds.MBps;
+    [Obsolete] public bool PreferNotesOverNamesForVisible { get; set; } = false;
+    public float ProfileDelay { get; set; } = 1.5f;
+    public bool ProfilePopoutRight { get; set; } = false;
+    public bool ProfilesAllowNsfw { get; set; } = false;
+    public bool ProfilesShow { get; set; } = false;
+    public bool ShowSyncshellUsersInVisible { get; set; } = true;
+    [Obsolete] public bool ShowCharacterNameInsteadOfNotesForVisible { get; set; } = false;
+    public bool ShowCharacterNames { get; set; } = true;
+    public bool ShowOfflineUsersSeparately { get; set; } = true;
+    public bool ShowSyncshellOfflineUsersSeparately { get; set; } = true;
+    public bool GroupUpSyncshells { get; set; } = true;
+    public bool SerialApplication { get; set; } = false;
+    public bool ShowOnlineNotifications { get; set; } = false;
+    public bool ShowOnlineNotificationsOnlyForIndividualPairs { get; set; } = true;
+    public bool ShowOnlineNotificationsOnlyForNamedPairs { get; set; } = false;
+    public bool ShowTransferBars { get; set; } = true;
+    public bool ShowTransferWindow { get; set; } = false;
+    public bool ShowUploading { get; set; } = true;
+    public bool ShowUploadingBigText { get; set; } = true;
+    public bool ShowVisibleUsersSeparately { get; set; } = true;
+    public int TimeSpanBetweenScansInSeconds { get; set; } = 30;
+    public int TransferBarsHeight { get; set; } = 12;
+    public bool TransferBarsShowText { get; set; } = true;
+    public int TransferBarsWidth { get; set; } = 250;
+    public bool UseAlternativeFileUpload { get; set; } = false;
+    public bool UseCompactor { get; set; } = false;
+    public int Version { get; set; } = 1;
+    public NotificationLocation WarningNotification { get; set; } = NotificationLocation.Both;
+
+    public bool DisableSyncshellChat { get; set; } = false;
+    public int ChatColor { get; set; } = 0; // 0 means "use plugin default"
+    public int ChatLogKind { get; set; } = 1; // XivChatType.Debug
+    public bool ExtraChatAPI { get; set; } = false;
+    public bool ExtraChatTags { get; set; } = false;
+
+    public bool MareAPI { get; set; } = true;
+}

MareSynchronos/MareConfiguration/Configurations/PlayerPerformanceConfig.cs

@@ -0,0 +1,16 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public class PlayerPerformanceConfig : IMareConfiguration
+{
+    public int Version { get; set; } = 1;
+    public bool AutoPausePlayersExceedingThresholds { get; set; } = false;
+    public bool NotifyAutoPauseDirectPairs { get; set; } = true;
+    public bool NotifyAutoPauseGroupPairs { get; set; } = false;
+    public int VRAMSizeAutoPauseThresholdMiB { get; set; } = 550;
+    public int TrisAutoPauseThresholdThousands { get; set; } = 375;
+    public bool IgnoreDirectPairs { get; set; } = true;
+    public TextureShrinkMode TextureShrinkMode { get; set; } = TextureShrinkMode.Default;
+    public bool TextureShrinkDeleteOriginal { get; set; } = false;
+}

MareSynchronos/MareConfiguration/Configurations/RemoteConfigCache.cs

@@ -0,0 +1,13 @@
+using System.Text.Json.Nodes;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public class RemoteConfigCache : IMareConfiguration
+{
+    public int Version { get; set; } = 0;
+    public ulong Timestamp { get; set; } = 0;
+    public string Origin { get; set; } = string.Empty;
+    public DateTimeOffset? LastModified { get; set; } = null;
+    public string ETag { get; set; } = string.Empty;
+    public JsonObject Configuration { get; set; } = new();
+}

MareSynchronos/MareConfiguration/Configurations/ServerBlockConfig.cs

@@ -0,0 +1,10 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+[Serializable]
+public class ServerBlockConfig : IMareConfiguration
+{
+    public Dictionary<string, ServerBlockStorage> ServerBlocks { get; set; } = new(StringComparer.Ordinal);
+    public int Version { get; set; } = 0;
+}

MareSynchronos/MareConfiguration/Configurations/ServerConfig.cs

@@ -0,0 +1,17 @@
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.WebAPI;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+[Serializable]
+public class ServerConfig : IMareConfiguration
+{
+    public int CurrentServer { get; set; } = 0;
+
+    public List<ServerStorage> ServerStorage { get; set; } = new()
+    {
+        { new ServerStorage() { ServerName = ApiController.ElezenServer, ServerUri = ApiController.ElezenServiceUri } },
+    };
+
+    public int Version { get; set; } = 1;
+}

MareSynchronos/MareConfiguration/Configurations/ServerTagConfig.cs

@@ -0,0 +1,10 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+[Serializable]
+public class ServerTagConfig : IMareConfiguration
+{
+    public Dictionary<string, ServerTagStorage> ServerTagStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public int Version { get; set; } = 0;
+}

MareSynchronos/MareConfiguration/Configurations/SyncshellConfig.cs

@@ -0,0 +1,10 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+[Serializable]
+public class SyncshellConfig : IMareConfiguration
+{
+    public Dictionary<string, ServerShellStorage> ServerShellStorage { get; set; } = new(StringComparer.Ordinal);
+    public int Version { get; set; } = 0;
+}

MareSynchronos/MareConfiguration/Configurations/TransientConfig.cs

@@ -0,0 +1,7 @@
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public class TransientConfig : IMareConfiguration
+{
+    public Dictionary<string, HashSet<string>> PlayerPersistentTransientCache { get; set; } = new(StringComparer.Ordinal);
+    public int Version { get; set; } = 0;
+}

MareSynchronos/MareConfiguration/Configurations/UidNotesConfig.cs

@@ -0,0 +1,10 @@
+using MareSynchronos.MareConfiguration.Models;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+[Serializable]
+public class UidNotesConfig : IMareConfiguration
+{
+    public Dictionary<string, ServerNotesStorage> ServerNotes { get; set; } = new(StringComparer.Ordinal);
+    public int Version { get; set; } = 0;
+}

MareSynchronos/MareConfiguration/Configurations/XivDataStorageConfig.cs

@@ -0,0 +1,11 @@
+using System.Collections.Concurrent;
+
+namespace MareSynchronos.MareConfiguration.Configurations;
+
+public class XivDataStorageConfig : IMareConfiguration
+{
+    public ConcurrentDictionary<string, long> TriangleDictionary { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public ConcurrentDictionary<string, (uint Mip0Size, int MipCount, ushort Width, ushort Height)> TexDictionary { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public ConcurrentDictionary<string, Dictionary<string, List<ushort>>> BonesDictionary { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public int Version { get; set; } = 0;
+}

MareSynchronos/MareConfiguration/IConfigService.cs

@@ -0,0 +1,12 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public interface IConfigService<out T> : IDisposable where T : IMareConfiguration
+{
+    T Current { get; }
+    string ConfigurationName { get; }
+    string ConfigurationPath { get; }
+    public event EventHandler? ConfigSave;
+    void UpdateLastWriteTime();
+}

MareSynchronos/MareConfiguration/MareConfigService.cs

@@ -0,0 +1,14 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class MareConfigService : ConfigurationServiceBase<MareConfig>
+{
+    public const string ConfigName = "config.json";
+
+    public MareConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/Models/Authentication.cs

@@ -0,0 +1,9 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public record Authentication
+{
+    public string CharacterName { get; set; } = string.Empty;
+    public uint WorldId { get; set; } = 0;
+    public int SecretKeyIdx { get; set; } = -1;
+}

MareSynchronos/MareConfiguration/Models/CharaDataFavorite.cs

@@ -0,0 +1,8 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class CharaDataFavorite
+{
+    public DateTime LastDownloaded { get; set; } = DateTime.MaxValue;
+    public string CustomDescription { get; set; } = string.Empty;
+}

MareSynchronos/MareConfiguration/Models/DownloadSpeeds.cs

@@ -0,0 +1,8 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+public enum DownloadSpeeds
+{
+    Bps,
+    KBps,
+    MBps
+}

MareSynchronos/MareConfiguration/Models/NotificationLocation.cs

@@ -0,0 +1,16 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+public enum NotificationLocation
+{
+    Nowhere,
+    Chat,
+    Toast,
+    Both
+}
+
+public enum NotificationType
+{
+    Info,
+    Warning,
+    Error
+}

MareSynchronos/MareConfiguration/Models/Obsolete/ServerStorageV0.cs

@@ -0,0 +1,29 @@
+namespace MareSynchronos.MareConfiguration.Models.Obsolete;
+
+[Serializable]
+[Obsolete("Deprecated, use ServerStorage")]
+public class ServerStorageV0
+{
+    public List<Authentication> Authentications { get; set; } = [];
+    public bool FullPause { get; set; } = false;
+    public Dictionary<string, string> GidServerComments { get; set; } = new(StringComparer.Ordinal);
+    public HashSet<string> OpenPairTags { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<int, SecretKey> SecretKeys { get; set; } = [];
+    public HashSet<string> ServerAvailablePairTags { get; set; } = new(StringComparer.Ordinal);
+    public string ServerName { get; set; } = string.Empty;
+    public string ServerUri { get; set; } = string.Empty;
+    public Dictionary<string, string> UidServerComments { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, List<string>> UidServerPairedUserTags { get; set; } = new(StringComparer.Ordinal);
+
+    public ServerStorage ToV1()
+    {
+        return new ServerStorage()
+        {
+            ServerUri = ServerUri,
+            ServerName = ServerName,
+            Authentications = [.. Authentications],
+            FullPause = FullPause,
+            SecretKeys = SecretKeys.ToDictionary(p => p.Key, p => p.Value)
+        };
+    }
+}

MareSynchronos/MareConfiguration/Models/SecretKey.cs

@@ -0,0 +1,8 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class SecretKey
+{
+    public string FriendlyName { get; set; } = string.Empty;
+    public string Key { get; set; } = string.Empty;
+}

MareSynchronos/MareConfiguration/Models/ServerBlockStorage.cs

@@ -0,0 +1,8 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class ServerBlockStorage
+{
+    public List<string> Whitelist { get; set; } = new();
+    public List<string> Blacklist { get; set; } = new();
+}

MareSynchronos/MareConfiguration/Models/ServerNotesStorage.cs

@@ -0,0 +1,9 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class ServerNotesStorage
+{
+    public Dictionary<string, string> GidServerComments { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, string> UidServerComments { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, string> UidLastSeenNames { get; set; } = new(StringComparer.Ordinal);
+}

MareSynchronos/MareConfiguration/Models/ServerShellStorage.cs

@@ -0,0 +1,7 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class ServerShellStorage
+{
+    public Dictionary<string, ShellConfig> GidShellConfig { get; set; } = new(StringComparer.Ordinal);
+}

MareSynchronos/MareConfiguration/Models/ServerStorage.cs

@@ -0,0 +1,11 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class ServerStorage
+{
+    public List<Authentication> Authentications { get; set; } = [];
+    public bool FullPause { get; set; } = false;
+    public Dictionary<int, SecretKey> SecretKeys { get; set; } = [];
+    public string ServerName { get; set; } = string.Empty;
+    public string ServerUri { get; set; } = string.Empty;
+}

MareSynchronos/MareConfiguration/Models/ServerTagStorage.cs

@@ -0,0 +1,9 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class ServerTagStorage
+{
+    public HashSet<string> OpenPairTags { get; set; } = new(StringComparer.Ordinal);
+    public HashSet<string> ServerAvailablePairTags { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, List<string>> UidServerPairedUserTags { get; set; } = new(StringComparer.Ordinal);
+}

MareSynchronos/MareConfiguration/Models/ShellConfig.cs

@@ -0,0 +1,10 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+[Serializable]
+public class ShellConfig
+{
+    public bool Enabled { get; set; } = true;
+    public int ShellNumber { get; set; }
+    public int Color { get; set; } = 0; // 0 means "default to the global setting"
+    public int LogKind { get; set; } = 0; // 0 means "default to the global setting"
+}

MareSynchronos/MareConfiguration/Models/TextureShrinkMode.cs

@@ -0,0 +1,10 @@
+namespace MareSynchronos.MareConfiguration.Models;
+
+public enum TextureShrinkMode
+{
+    Never,
+    Default,
+    DefaultHiRes,
+    Always,
+    AlwaysHiRes
+}

MareSynchronos/MareConfiguration/NotesConfigService.cs

@@ -0,0 +1,14 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class NotesConfigService : ConfigurationServiceBase<UidNotesConfig>
+{
+    public const string ConfigName = "notes.json";
+
+    public NotesConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/PlayerPerformanceConfigService.cs

@@ -0,0 +1,11 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class PlayerPerformanceConfigService : ConfigurationServiceBase<PlayerPerformanceConfig>
+{
+    public const string ConfigName = "playerperformance.json";
+    public PlayerPerformanceConfigService(string configDir) : base(configDir) { }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/RemoteConfigCacheService.cs

@@ -0,0 +1,11 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class RemoteConfigCacheService : ConfigurationServiceBase<RemoteConfigCache>
+{
+    public const string ConfigName = "remotecache.json";
+
+    public RemoteConfigCacheService(string configDir) : base(configDir) { }
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/ServerBlockConfigService.cs

@@ -0,0 +1,14 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class ServerBlockConfigService : ConfigurationServiceBase<ServerBlockConfig>
+{
+    public const string ConfigName = "blocks.json";
+
+    public ServerBlockConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/ServerConfigService.cs

@@ -0,0 +1,14 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class ServerConfigService : ConfigurationServiceBase<ServerConfig>
+{
+    public const string ConfigName = "server.json";
+
+    public ServerConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/ServerTagConfigService.cs

@@ -0,0 +1,14 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class ServerTagConfigService : ConfigurationServiceBase<ServerTagConfig>
+{
+    public const string ConfigName = "servertags.json";
+
+    public ServerTagConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/SyncshellConfigService.cs

@@ -0,0 +1,14 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class SyncshellConfigService : ConfigurationServiceBase<SyncshellConfig>
+{
+    public const string ConfigName = "syncshells.json";
+
+    public SyncshellConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/TransientConfigService.cs

@@ -0,0 +1,14 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class TransientConfigService : ConfigurationServiceBase<TransientConfig>
+{
+    public const string ConfigName = "transient.json";
+
+    public TransientConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MareConfiguration/XivDataStorageService.cs

@@ -0,0 +1,12 @@
+using MareSynchronos.MareConfiguration.Configurations;
+
+namespace MareSynchronos.MareConfiguration;
+
+public class XivDataStorageService : ConfigurationServiceBase<XivDataStorageConfig>
+{
+    public const string ConfigName = "xivdatastorage.json";
+
+    public XivDataStorageService(string configDir) : base(configDir) { }
+
+    public override string ConfigurationName => ConfigName;
+}

MareSynchronos/MarePlugin.cs

@@ -0,0 +1,170 @@
+using MareSynchronos.FileCache;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.PlayerData.Services;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System.Reflection;
+
+namespace MareSynchronos;
+
+#pragma warning disable S125 // Sections of code should not be commented out
+/*
+                                                                    (..,,...,,,,,+/,                ,,.....,,+
+                                                              ..,,+++/((###%%%&&%%#(+,,.,,,+++,,,,//,,#&@@@@%+.
+                                                          ...+//////////(/,,,,++,.,(###((//////////,..  .,#@@%/./
+                                                       ,..+/////////+///,.,. ,&@@@@,,/////////////+,..    ,(##+,.
+                                                    ,,.+//////////++++++..     ./#%#,+/////////////+,....,/((,..,
+                                                  +..////////////+++++++...  .../##(,,////////////////++,,,+/(((+,
+                                                +,.+//////////////+++++++,.,,,/(((+.,////////////////////////((((#/,,
+                                              /+.+//////////++++/++++++++++,,...,++///////////////////////////((((##,
+                                             /,.////////+++++++++++++++++++++////////+++//////++/+++++//////////((((#(+,
+                                           /+.+////////+++++++++++++++++++++++++++++++++++++++++++++++++++++/////((((##+
+                                          +,.///////////////+++++++++++++++++++++++++++++++++++++++++++++++++++///((((%/
+                                         /.,/////////////////+++++++++++++++++++++++++++++++++++++++++++++++++++///+/(#+
+                                        +,./////////////////+++++++++++++++++++++++++++++++++++++++++++++++,,+++++///((,
+                                       ...////////++/++++++++++++++++++++++++,,++++++++++++++++++++++++++++++++++++//(,,
+                                       ..//+,+///++++++++++++++++++,,,,+++,,,,,,,,,,,,++++++++,,+++++++++++++++++++//,,+
+                                      ..,++,.++++++++++++++++++++++,,,,,,,,,,,,,,,,,,,++++++++,,,,,,,,,,++++++++++...
+                                      ..+++,.+++++++++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,++,..,.
+                                     ..,++++,,+++++++++++,+,,,,,,,,,,..,+++++++++,,,,,,.....................,//+,+
+                                 ....,+++++,.,+++++++++++,,,,,,,,.+///(((((((((((((///////////////////////(((+,,,
+                          .....,++++++++++..,+++++++++++,,.,,,.////////(((((((((((((((////////////////////+,,/
+                      .....,++++++++++++,..,,+++++++++,,.,../////////////////((((((((((//////////////////,,+
+                   ...,,+++++++++++++,.,,.,,,+++++++++,.,/////////////////(((//++++++++++++++//+++++++++/,,
+                ....,++++++++++++++,.,++.,++++++++++++.,+////////////////////+++++++++++++++++++++++++///,,..
+              ...,++++++++++++++++..+++..+++++++++++++.,//////////////////////////++++++++++++///////++++......
+            ...++++++++++++++++++..++++.,++,++++++++++.+///////////////////////////////////////////++++++..,,,..
+          ...+++++++++++++++++++..+++++..,+,,+++++++++.+//////////////////////////////////////////+++++++...,,,,..
+         ..++++++++++++++++++++..++++++..,+,,+++++++++.+//////////////////////////////////////++++++++++,....,,,,..
+       ...+++//(//////+++++++++..++++++,.,+++++++++++++,..,....,,,+++///////////////////////++++++++++++..,,,,,,,,...
+      ..,++/(((((//////+++++++,.,++++++,,.,,,+++++++++++++++++++++++,.++////////////////////+++++++++++.....,,,,,,,...
+     ..,//#(((((///////+++++++..++++++++++,...,++,++++++++++++++++,...+++/////////////////////+,,,+++...  ....,,,,,,...
+   ...+//(((((//////////++++++..+++++++++++++++,......,,,,++++++,,,..+++////////////////////////+,....     ...,,,,,,,...
+   ..,//((((////////////++++++..++++++/+++++++++++++,,...,,........,+/+//////////////////////((((/+,..     ....,.,,,,..
+  ...+/////////////////////+++..++++++/+///+++++++++++++++++++++///+/+////////////////////////(((((/+...   .......,,...
+  ..++////+++//////////////++++.+++++++++///////++++++++////////////////////////////////////+++/(((((/+..    .....,,...
+  .,++++++++///////////////++++..++++//////////////////////////////////////////////////////++++++/((((++..    ........
+  .+++++++++////////////////++++,.+++/////////////////////////////////////////////////////+++++++++/((/++..
+ .,++++++++//////////////////++++,.+++//////////////////////////////////////////////////+++++++++++++//+++..
+ .++++++++//////////////////////+/,.,+++////((((////////////////////////////////////////++++++++++++++++++...
+ .++++++++///////////////////////+++..++++//((((((((///////////////////////////////////++++++++++++++++++++ .
+ .++++++///////////////////////////++,.,+++++/(((((((((/////////////////////////////+++++++++++++++++++++++,..
+ .++++++////////////////////////////+++,.,+++++++/((((((((//////////////////////////++++++++++++++++++++++++..
+ .+++++++///////////////////++////////++++,.,+++++++++///////////+////////////////+++++++++++++++++++++++++,..
+ ..++++++++++//////////////////////+++++++..+...,+++++++++++++++/++++++++++++++++++++++++++++++++++++++++++,...
+  ..++++++++++++///////////////+++++++,...,,,,,.,....,,,,+++++++++++++++++++++++++++++++++++++++++++++++,,,,...
+  ...++++++++++++++++++++++++++,,,,...,,,,,,,,,..,,++,,,.,,,,,,,,,,,,,,,,,,+++++++++++++++++++++++++,,,,,,,,..
+   ...+++++++++++++++,,,,,,,,....,,,,,,,,,,,,,,,..,,++++++,,,,,,,,,,,,,,,,+++++++++++++++++++++++++,,,,,,,,,..
+     ...++++++++++++,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,...,++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,,,...
+       ,....,++++++++++++++,,,+++++++,,,,,,,,,,,,,,,,,.,++++++++++++++++++++++++++++++++++++++++++++,,,,,,,,..
+
+*/
+#pragma warning restore S125 // Sections of code should not be commented out
+
+public class MarePlugin : MediatorSubscriberBase, IHostedService
+{
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly MareConfigService _mareConfigService;
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+    private readonly IServiceScopeFactory _serviceScopeFactory;
+    private IServiceScope? _runtimeServiceScope;
+    private Task? _launchTask = null;
+
+    public MarePlugin(ILogger<MarePlugin> logger, MareConfigService mareConfigService,
+        ServerConfigurationManager serverConfigurationManager,
+        DalamudUtilService dalamudUtil,
+        IServiceScopeFactory serviceScopeFactory, MareMediator mediator) : base(logger, mediator)
+    {
+        _mareConfigService = mareConfigService;
+        _serverConfigurationManager = serverConfigurationManager;
+        _dalamudUtil = dalamudUtil;
+        _serviceScopeFactory = serviceScopeFactory;
+    }
+
+    public Task StartAsync(CancellationToken cancellationToken)
+    {
+        var version = Assembly.GetExecutingAssembly().GetName().Version!;
+        Logger.LogInformation("Launching {name} {major}.{minor}.{build}.{rev}", "Elezen Sync", version.Major, version.Minor, version.Build, version.Revision);
+        Mediator.Publish(new EventMessage(new Services.Events.Event(nameof(MarePlugin), Services.Events.EventSeverity.Informational,
+            $"Starting Elezen Sync {version.Major}.{version.Minor}.{version.Build}.{version.Revision}")));
+
+        Mediator.Subscribe<SwitchToMainUiMessage>(this, (msg) => { if (_launchTask == null || _launchTask.IsCompleted) _launchTask = Task.Run(WaitForPlayerAndLaunchCharacterManager); });
+        Mediator.Subscribe<DalamudLoginMessage>(this, (_) => DalamudUtilOnLogIn());
+        Mediator.Subscribe<DalamudLogoutMessage>(this, (_) => DalamudUtilOnLogOut());
+
+        Mediator.StartQueueProcessing();
+
+        return Task.CompletedTask;
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken)
+    {
+        UnsubscribeAll();
+
+        DalamudUtilOnLogOut();
+
+        Logger.LogDebug("Halting MarePlugin");
+
+        return Task.CompletedTask;
+    }
+
+    private void DalamudUtilOnLogIn()
+    {
+        Logger?.LogDebug("Client login");
+        if (_launchTask == null || _launchTask.IsCompleted) _launchTask = Task.Run(WaitForPlayerAndLaunchCharacterManager);
+    }
+
+    private void DalamudUtilOnLogOut()
+    {
+        Logger?.LogDebug("Client logout");
+
+        _runtimeServiceScope?.Dispose();
+    }
+
+    private async Task WaitForPlayerAndLaunchCharacterManager()
+    {
+        while (!await _dalamudUtil.GetIsPlayerPresentAsync().ConfigureAwait(false))
+        {
+            await Task.Delay(100).ConfigureAwait(false);
+        }
+
+        try
+        {
+            Logger?.LogDebug("Launching Managers");
+
+            _runtimeServiceScope?.Dispose();
+            _runtimeServiceScope = _serviceScopeFactory.CreateScope();
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<UiService>();
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<CommandManagerService>();
+            if (!_mareConfigService.Current.HasValidSetup() || !_serverConfigurationManager.HasValidConfig())
+            {
+                Mediator.Publish(new SwitchToIntroUiMessage());
+                return;
+            }
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<CacheCreationService>();
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<TransientResourceManager>();
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<OnlinePlayerManager>();
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<NotificationService>();
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<ChatService>();
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<GuiHookService>();
+
+#if !DEBUG
+            if (_mareConfigService.Current.LogLevel != LogLevel.Information)
+            {
+                Mediator.Publish(new NotificationMessage("Abnormal Log Level",
+                    $"Your log level is set to '{_mareConfigService.Current.LogLevel}' which is not recommended for normal usage. Set it to '{LogLevel.Information}' in \"Elezen Settings -> Debug\" unless instructed otherwise.",
+                    MareConfiguration.Models.NotificationType.Error, TimeSpan.FromSeconds(15000)));
+            }
+#endif
+        }
+        catch (Exception ex)
+        {
+            Logger?.LogCritical(ex, "Error during launch of managers");
+        }
+    }
+}

MareSynchronos/MareSynchronos.csproj

@@ -0,0 +1,63 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Dalamud.NET.Sdk/13.0.0">
+  <PropertyGroup>
+    <AssemblyName>ElezenSync</AssemblyName>
+    <Version>9.9.0</Version>
+    <PackageProjectUrl>https://github.com/Elezen/MareClient/</PackageProjectUrl>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="PlayerData\Export\**" />
+    <EmbeddedResource Remove="PlayerData\Export\**" />
+    <None Remove="PlayerData\Export\**" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Chaos.NaCl.Standard" Version="1.0.0" />
+    <PackageReference Include="Downloader" Version="3.3.4" />
+    <PackageReference Include="K4os.Compression.LZ4.Legacy" Version="1.3.8" />
+    <PackageReference Include="K4os.Compression.LZ4.Streams" Version="1.3.8" />
+    <PackageReference Include="Meziantou.Analyzer" Version="2.0.189">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="9.0.3" />
+    <PackageReference Include="Microsoft.AspNetCore.SignalR.Protocols.MessagePack" Version="9.0.3" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="9.0.3" />
+    <PackageReference Include="SonarAnalyzer.CSharp" Version="10.7.0.110445">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.7.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition="Exists('.\Penumbra.Api\Penumbra.Api.csproj')">
+    <ProjectReference Include=".\Penumbra.Api\Penumbra.Api.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="!Exists('.\Penumbra.Api\Penumbra.Api.csproj')">
+    <PackageReference Include="Penumbra.Api" Version="5.6.1" />
+  </ItemGroup>
+
+  <ItemGroup Condition="Exists('.\Glamourer.Api\Glamourer.Api.csproj')">
+    <ProjectReference Include=".\Glamourer.Api\Glamourer.Api.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition="!Exists('.\Glamourer.Api\Glamourer.Api.csproj')">
+    <PackageReference Include="Glamourer.Api" Version="2.4.1" />
+  </ItemGroup>
+
+  <PropertyGroup>
+    <SourceRevisionId>build$([System.DateTime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ss:fffZ"))</SourceRevisionId>
+    <ImplicitUsings>enable</ImplicitUsings>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\MareAPI\MareSynchronosAPI\MareSynchronos.API.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="..\.editorconfig" Link=".editorconfig" />
+  </ItemGroup>
+
+</Project>

MareSynchronos/PlayerData/Data/CharacterData.cs

@@ -0,0 +1,50 @@
+using MareSynchronos.API.Data;
+
+using MareSynchronos.API.Data.Enum;
+
+namespace MareSynchronos.PlayerData.Data;
+
+public class CharacterData
+{
+    public Dictionary<ObjectKind, string> CustomizePlusScale { get; set; } = [];
+    public Dictionary<ObjectKind, HashSet<FileReplacement>> FileReplacements { get; set; } = [];
+    public Dictionary<ObjectKind, string> GlamourerString { get; set; } = [];
+    public string HeelsData { get; set; } = string.Empty;
+    public string HonorificData { get; set; } = string.Empty;
+    public string ManipulationString { get; set; } = string.Empty;
+    public string PetNamesData { get; set; } = string.Empty;
+    public string MoodlesData { get; set; } = string.Empty;
+
+    public API.Data.CharacterData ToAPI()
+    {
+        Dictionary<ObjectKind, List<FileReplacementData>> fileReplacements =
+            FileReplacements.ToDictionary(k => k.Key, k => k.Value.Where(f => f.HasFileReplacement && !f.IsFileSwap)
+            .GroupBy(f => f.Hash, StringComparer.OrdinalIgnoreCase)
+            .Select(g =>
+        {
+            return new FileReplacementData()
+            {
+                GamePaths = g.SelectMany(f => f.GamePaths).Distinct(StringComparer.OrdinalIgnoreCase).ToArray(),
+                Hash = g.First().Hash,
+            };
+        }).ToList());
+
+        foreach (var item in FileReplacements)
+        {
+            var fileSwapsToAdd = item.Value.Where(f => f.IsFileSwap).Select(f => f.ToFileReplacementDto());
+            fileReplacements[item.Key].AddRange(fileSwapsToAdd);
+        }
+
+        return new API.Data.CharacterData()
+        {
+            FileReplacements = fileReplacements,
+            GlamourerData = GlamourerString.ToDictionary(d => d.Key, d => d.Value),
+            ManipulationData = ManipulationString,
+            HeelsData = HeelsData,
+            CustomizePlusData = CustomizePlusScale.ToDictionary(d => d.Key, d => d.Value),
+            HonorificData = HonorificData,
+            PetNamesData = PetNamesData,
+            MoodlesData = MoodlesData
+        };
+    }
+}

MareSynchronos/PlayerData/Data/FileReplacement.cs

@@ -0,0 +1,42 @@
+using MareSynchronos.API.Data;
+
+using System.Text.RegularExpressions;
+
+namespace MareSynchronos.PlayerData.Data;
+
+public partial class FileReplacement
+{
+    public FileReplacement(string[] gamePaths, string filePath)
+    {
+        GamePaths = gamePaths.Select(g => g.Replace('\\', '/').ToLowerInvariant()).ToHashSet(StringComparer.Ordinal);
+        ResolvedPath = filePath.Replace('\\', '/');
+    }
+
+    public HashSet<string> GamePaths { get; init; }
+
+    public bool HasFileReplacement => GamePaths.Count >= 1 && GamePaths.Any(p => !string.Equals(p, ResolvedPath, StringComparison.Ordinal));
+
+    public string Hash { get; set; } = string.Empty;
+    public bool IsFileSwap => !LocalPathRegex().IsMatch(ResolvedPath) && GamePaths.All(p => !LocalPathRegex().IsMatch(p));
+    public string ResolvedPath { get; init; }
+
+    public FileReplacementData ToFileReplacementDto()
+    {
+        return new FileReplacementData
+        {
+            GamePaths = [.. GamePaths],
+            Hash = Hash,
+            FileSwapPath = IsFileSwap ? ResolvedPath : string.Empty,
+        };
+    }
+
+    public override string ToString()
+    {
+        return $"HasReplacement:{HasFileReplacement},IsFileSwap:{IsFileSwap} - {string.Join(",", GamePaths)} => {ResolvedPath}";
+    }
+
+#pragma warning disable MA0009
+    [GeneratedRegex(@"^[a-zA-Z]:(/|\\)", RegexOptions.ECMAScript)]
+    private static partial Regex LocalPathRegex();
+#pragma warning restore MA0009
+}

MareSynchronos/PlayerData/Data/FileReplacementComparer.cs

@@ -0,0 +1,47 @@
+namespace MareSynchronos.PlayerData.Data;
+
+public class FileReplacementComparer : IEqualityComparer<FileReplacement>
+{
+    private static readonly FileReplacementComparer _instance = new();
+
+    private FileReplacementComparer()
+    { }
+
+    public static FileReplacementComparer Instance => _instance;
+
+    public bool Equals(FileReplacement? x, FileReplacement? y)
+    {
+        if (x == null || y == null) return false;
+        return x.ResolvedPath.Equals(y.ResolvedPath) && CompareLists(x.GamePaths, y.GamePaths);
+    }
+
+    public int GetHashCode(FileReplacement obj)
+    {
+        return HashCode.Combine(obj.ResolvedPath.GetHashCode(StringComparison.OrdinalIgnoreCase), GetOrderIndependentHashCode(obj.GamePaths));
+    }
+
+    private static bool CompareLists(HashSet<string> list1, HashSet<string> list2)
+    {
+        if (list1.Count != list2.Count)
+            return false;
+
+        for (int i = 0; i < list1.Count; i++)
+        {
+            if (!string.Equals(list1.ElementAt(i), list2.ElementAt(i), StringComparison.OrdinalIgnoreCase))
+                return false;
+        }
+
+        return true;
+    }
+
+    private static int GetOrderIndependentHashCode<T>(IEnumerable<T> source) where T : notnull
+    {
+        int hash = 0;
+        foreach (T element in source)
+        {
+            hash = unchecked(hash +
+                EqualityComparer<T>.Default.GetHashCode(element));
+        }
+        return hash;
+    }
+}

MareSynchronos/PlayerData/Data/FileReplacementDataComparer.cs

@@ -0,0 +1,49 @@
+using MareSynchronos.API.Data;
+
+namespace MareSynchronos.PlayerData.Data;
+
+public class FileReplacementDataComparer : IEqualityComparer<FileReplacementData>
+{
+    private static readonly FileReplacementDataComparer _instance = new();
+
+    private FileReplacementDataComparer()
+    { }
+
+    public static FileReplacementDataComparer Instance => _instance;
+
+    public bool Equals(FileReplacementData? x, FileReplacementData? y)
+    {
+        if (x == null || y == null) return false;
+        return x.Hash.Equals(y.Hash) && CompareHashSets(x.GamePaths.ToHashSet(StringComparer.Ordinal), y.GamePaths.ToHashSet(StringComparer.Ordinal)) && string.Equals(x.FileSwapPath, y.FileSwapPath, StringComparison.Ordinal);
+    }
+
+    public int GetHashCode(FileReplacementData obj)
+    {
+        return HashCode.Combine(obj.Hash.GetHashCode(StringComparison.OrdinalIgnoreCase), GetOrderIndependentHashCode(obj.GamePaths), StringComparer.Ordinal.GetHashCode(obj.FileSwapPath));
+    }
+
+    private static bool CompareHashSets(HashSet<string> list1, HashSet<string> list2)
+    {
+        if (list1.Count != list2.Count)
+            return false;
+
+        for (int i = 0; i < list1.Count; i++)
+        {
+            if (!string.Equals(list1.ElementAt(i), list2.ElementAt(i), StringComparison.OrdinalIgnoreCase))
+                return false;
+        }
+
+        return true;
+    }
+
+    private static int GetOrderIndependentHashCode<T>(IEnumerable<T> source) where T : notnull
+    {
+        int hash = 0;
+        foreach (T element in source)
+        {
+            hash = unchecked(hash +
+                EqualityComparer<T>.Default.GetHashCode(element));
+        }
+        return hash;
+    }
+}

MareSynchronos/PlayerData/Data/PlayerChanges.cs

@@ -0,0 +1,14 @@
+namespace MareSynchronos.PlayerData.Pairs;
+
+public enum PlayerChanges
+{
+    ModFiles = 1,
+    ModManip = 2,
+    Glamourer = 3,
+    Customize = 4,
+    Heels = 5,
+    Honorific = 7,
+    ForcedRedraw = 8,
+    Moodles = 9,
+    PetNames = 10,
+}

MareSynchronos/PlayerData/Factories/FileDownloadManagerFactory.cs

@@ -0,0 +1,30 @@
+using MareSynchronos.FileCache;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.WebAPI.Files;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.PlayerData.Factories;
+
+public class FileDownloadManagerFactory
+{
+    private readonly FileCacheManager _fileCacheManager;
+    private readonly FileCompactor _fileCompactor;
+    private readonly FileTransferOrchestrator _fileTransferOrchestrator;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly MareMediator _mareMediator;
+
+    public FileDownloadManagerFactory(ILoggerFactory loggerFactory, MareMediator mareMediator, FileTransferOrchestrator fileTransferOrchestrator,
+        FileCacheManager fileCacheManager, FileCompactor fileCompactor)
+    {
+        _loggerFactory = loggerFactory;
+        _mareMediator = mareMediator;
+        _fileTransferOrchestrator = fileTransferOrchestrator;
+        _fileCacheManager = fileCacheManager;
+        _fileCompactor = fileCompactor;
+    }
+
+    public FileDownloadManager Create()
+    {
+        return new FileDownloadManager(_loggerFactory.CreateLogger<FileDownloadManager>(), _mareMediator, _fileTransferOrchestrator, _fileCacheManager, _fileCompactor);
+    }
+}

MareSynchronos/PlayerData/Factories/GameObjectHandlerFactory.cs

@@ -0,0 +1,30 @@
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.PlayerData.Factories;
+
+public class GameObjectHandlerFactory
+{
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly MareMediator _mareMediator;
+    private readonly PerformanceCollectorService _performanceCollectorService;
+
+    public GameObjectHandlerFactory(ILoggerFactory loggerFactory, PerformanceCollectorService performanceCollectorService, MareMediator mareMediator,
+        DalamudUtilService dalamudUtilService)
+    {
+        _loggerFactory = loggerFactory;
+        _performanceCollectorService = performanceCollectorService;
+        _mareMediator = mareMediator;
+        _dalamudUtilService = dalamudUtilService;
+    }
+
+    public async Task<GameObjectHandler> Create(ObjectKind objectKind, Func<nint> getAddressFunc, bool isWatched = false)
+    {
+        return await _dalamudUtilService.RunOnFrameworkThread(() => new GameObjectHandler(_loggerFactory.CreateLogger<GameObjectHandler>(),
+            _performanceCollectorService, _mareMediator, _dalamudUtilService, objectKind, getAddressFunc, isWatched)).ConfigureAwait(false);
+    }
+}

MareSynchronos/PlayerData/Factories/PairAnalyzerFactory.cs

@@ -0,0 +1,30 @@
+using MareSynchronos.FileCache;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.PlayerData.Factories;
+
+public class PairAnalyzerFactory
+{
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly MareMediator _mareMediator;
+    private readonly FileCacheManager _fileCacheManager;
+    private readonly XivDataAnalyzer _modelAnalyzer;
+
+    public PairAnalyzerFactory(ILoggerFactory loggerFactory, MareMediator mareMediator,
+        FileCacheManager fileCacheManager, XivDataAnalyzer modelAnalyzer)
+    {
+        _loggerFactory = loggerFactory;
+        _fileCacheManager = fileCacheManager;
+        _mareMediator = mareMediator;
+        _modelAnalyzer = modelAnalyzer;
+    }
+
+    public PairAnalyzer Create(Pair pair)
+    {
+        return new PairAnalyzer(_loggerFactory.CreateLogger<PairAnalyzer>(), pair, _mareMediator,
+            _fileCacheManager, _modelAnalyzer);
+    }
+}

MareSynchronos/PlayerData/Factories/PairFactory.cs

@@ -0,0 +1,33 @@
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Dto.Group;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.PlayerData.Factories;
+
+public class PairFactory
+{
+    private readonly PairHandlerFactory _cachedPlayerFactory;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly MareMediator _mareMediator;
+    private readonly MareConfigService _mareConfig;
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+
+    public PairFactory(ILoggerFactory loggerFactory, PairHandlerFactory cachedPlayerFactory,
+        MareMediator mareMediator, MareConfigService mareConfig, ServerConfigurationManager serverConfigurationManager)
+    {
+        _loggerFactory = loggerFactory;
+        _cachedPlayerFactory = cachedPlayerFactory;
+        _mareMediator = mareMediator;
+        _mareConfig = mareConfig;
+        _serverConfigurationManager = serverConfigurationManager;
+    }
+
+    public Pair Create(UserData userData)
+    {
+        return new Pair(_loggerFactory.CreateLogger<Pair>(), userData, _cachedPlayerFactory, _mareMediator, _mareConfig, _serverConfigurationManager);
+    }
+}

MareSynchronos/PlayerData/Factories/PairHandlerFactory.cs

@@ -0,0 +1,62 @@
+using MareSynchronos.FileCache;
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.PlayerData.Factories;
+
+public class PairHandlerFactory
+{
+    private readonly MareConfigService _configService;
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly FileCacheManager _fileCacheManager;
+    private readonly FileDownloadManagerFactory _fileDownloadManagerFactory;
+    private readonly GameObjectHandlerFactory _gameObjectHandlerFactory;
+    private readonly IHostApplicationLifetime _hostApplicationLifetime;
+    private readonly IpcManager _ipcManager;
+    private readonly ILoggerFactory _loggerFactory;
+    private readonly MareMediator _mareMediator;
+    private readonly PlayerPerformanceService _playerPerformanceService;
+    private readonly ServerConfigurationManager _serverConfigManager;
+    private readonly PluginWarningNotificationService _pluginWarningNotificationManager;
+    private readonly PairAnalyzerFactory _pairAnalyzerFactory;
+    private readonly VisibilityService _visibilityService;
+    private readonly NoSnapService _noSnapService;
+
+    public PairHandlerFactory(ILoggerFactory loggerFactory, GameObjectHandlerFactory gameObjectHandlerFactory, IpcManager ipcManager,
+        FileDownloadManagerFactory fileDownloadManagerFactory, DalamudUtilService dalamudUtilService,
+        PluginWarningNotificationService pluginWarningNotificationManager, IHostApplicationLifetime hostApplicationLifetime,
+        FileCacheManager fileCacheManager, MareMediator mareMediator, PlayerPerformanceService playerPerformanceService,
+        ServerConfigurationManager serverConfigManager, PairAnalyzerFactory pairAnalyzerFactory,
+        MareConfigService configService, VisibilityService visibilityService, NoSnapService noSnapService)
+    {
+        _loggerFactory = loggerFactory;
+        _gameObjectHandlerFactory = gameObjectHandlerFactory;
+        _ipcManager = ipcManager;
+        _fileDownloadManagerFactory = fileDownloadManagerFactory;
+        _dalamudUtilService = dalamudUtilService;
+        _pluginWarningNotificationManager = pluginWarningNotificationManager;
+        _hostApplicationLifetime = hostApplicationLifetime;
+        _fileCacheManager = fileCacheManager;
+        _mareMediator = mareMediator;
+        _playerPerformanceService = playerPerformanceService;
+        _serverConfigManager = serverConfigManager;
+        _pairAnalyzerFactory = pairAnalyzerFactory;
+        _configService = configService;
+        _visibilityService = visibilityService;
+        _noSnapService = noSnapService;
+    }
+
+    public PairHandler Create(Pair pair)
+    {
+        return new PairHandler(_loggerFactory.CreateLogger<PairHandler>(), pair, _pairAnalyzerFactory.Create(pair), _gameObjectHandlerFactory,
+            _ipcManager, _fileDownloadManagerFactory.Create(), _pluginWarningNotificationManager, _dalamudUtilService, _hostApplicationLifetime,
+            _fileCacheManager, _mareMediator, _playerPerformanceService, _serverConfigManager, _configService, _visibilityService, _noSnapService);
+    }
+}

MareSynchronos/PlayerData/Factories/PlayerDataFactory.cs

@@ -0,0 +1,365 @@
+using FFXIVClientStructs.FFXIV.Client.Game.Character;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.FileCache;
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.PlayerData.Data;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using CharacterData = MareSynchronos.PlayerData.Data.CharacterData;
+
+namespace MareSynchronos.PlayerData.Factories;
+
+public class PlayerDataFactory
+{
+    private static readonly string[] _allowedExtensionsForGamePaths = [".mdl", ".tex", ".mtrl", ".tmb", ".pap", ".avfx", ".atex", ".sklb", ".eid", ".phyb", ".pbd", ".scd", ".skp", ".shpk"];
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly FileCacheManager _fileCacheManager;
+    private readonly IpcManager _ipcManager;
+    private readonly ILogger<PlayerDataFactory> _logger;
+    private readonly PerformanceCollectorService _performanceCollector;
+    private readonly XivDataAnalyzer _modelAnalyzer;
+    private readonly MareMediator _mareMediator;
+    private readonly TransientResourceManager _transientResourceManager;
+
+    public PlayerDataFactory(ILogger<PlayerDataFactory> logger, DalamudUtilService dalamudUtil, IpcManager ipcManager,
+        TransientResourceManager transientResourceManager, FileCacheManager fileReplacementFactory,
+        PerformanceCollectorService performanceCollector, XivDataAnalyzer modelAnalyzer, MareMediator mareMediator)
+    {
+        _logger = logger;
+        _dalamudUtil = dalamudUtil;
+        _ipcManager = ipcManager;
+        _transientResourceManager = transientResourceManager;
+        _fileCacheManager = fileReplacementFactory;
+        _performanceCollector = performanceCollector;
+        _modelAnalyzer = modelAnalyzer;
+        _mareMediator = mareMediator;
+        _logger.LogTrace("Creating {this}", nameof(PlayerDataFactory));
+    }
+
+    public async Task BuildCharacterData(CharacterData previousData, GameObjectHandler playerRelatedObject, CancellationToken token)
+    {
+        if (!_ipcManager.Initialized)
+        {
+            throw new InvalidOperationException("Penumbra or Glamourer is not connected");
+        }
+
+        if (playerRelatedObject == null) return;
+
+        bool pointerIsZero = true;
+        try
+        {
+            pointerIsZero = playerRelatedObject.Address == IntPtr.Zero;
+            try
+            {
+                pointerIsZero = await CheckForNullDrawObject(playerRelatedObject.Address).ConfigureAwait(false);
+            }
+            catch
+            {
+                pointerIsZero = true;
+                _logger.LogDebug("NullRef for {object}", playerRelatedObject);
+            }
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Could not create data for {object}", playerRelatedObject);
+        }
+
+        if (pointerIsZero)
+        {
+            _logger.LogTrace("Pointer was zero for {objectKind}", playerRelatedObject.ObjectKind);
+            previousData.FileReplacements.Remove(playerRelatedObject.ObjectKind);
+            previousData.GlamourerString.Remove(playerRelatedObject.ObjectKind);
+            previousData.CustomizePlusScale.Remove(playerRelatedObject.ObjectKind);
+            return;
+        }
+
+        var previousFileReplacements = previousData.FileReplacements.ToDictionary(d => d.Key, d => d.Value);
+        var previousGlamourerData = previousData.GlamourerString.ToDictionary(d => d.Key, d => d.Value);
+        var previousCustomize = previousData.CustomizePlusScale.ToDictionary(d => d.Key, d => d.Value);
+
+        try
+        {
+            await _performanceCollector.LogPerformance(this, $"CreateCharacterData>{playerRelatedObject.ObjectKind}", async () =>
+            {
+                await CreateCharacterData(previousData, playerRelatedObject, token).ConfigureAwait(false);
+            }).ConfigureAwait(true);
+            return;
+        }
+        catch (OperationCanceledException)
+        {
+            _logger.LogDebug("Cancelled creating Character data for {object}", playerRelatedObject);
+            throw;
+        }
+        catch (Exception e)
+        {
+            _logger.LogWarning(e, "Failed to create {object} data", playerRelatedObject);
+        }
+
+        previousData.FileReplacements = previousFileReplacements;
+        previousData.GlamourerString = previousGlamourerData;
+        previousData.CustomizePlusScale = previousCustomize;
+    }
+
+    private async Task<bool> CheckForNullDrawObject(IntPtr playerPointer)
+    {
+        return await _dalamudUtil.RunOnFrameworkThread(() => CheckForNullDrawObjectUnsafe(playerPointer)).ConfigureAwait(false);
+    }
+
+    private unsafe bool CheckForNullDrawObjectUnsafe(IntPtr playerPointer)
+    {
+        return ((Character*)playerPointer)->GameObject.DrawObject == null;
+    }
+
+    private async Task<CharacterData> CreateCharacterData(CharacterData previousData, GameObjectHandler playerRelatedObject, CancellationToken token)
+    {
+        var objectKind = playerRelatedObject.ObjectKind;
+
+        _logger.LogDebug("Building character data for {obj}", playerRelatedObject);
+
+        if (!previousData.FileReplacements.TryGetValue(objectKind, out HashSet<FileReplacement>? value))
+        {
+            previousData.FileReplacements[objectKind] = new(FileReplacementComparer.Instance);
+        }
+        else
+        {
+            value.Clear();
+        }
+
+        previousData.CustomizePlusScale.Remove(objectKind);
+
+        // wait until chara is not drawing and present so nothing spontaneously explodes
+        await _dalamudUtil.WaitWhileCharacterIsDrawing(_logger, playerRelatedObject, Guid.NewGuid(), 30000, ct: token).ConfigureAwait(false);
+        int totalWaitTime = 10000;
+        while (!await _dalamudUtil.IsObjectPresentAsync(await _dalamudUtil.CreateGameObjectAsync(playerRelatedObject.Address).ConfigureAwait(false)).ConfigureAwait(false) && totalWaitTime > 0)
+        {
+            _logger.LogTrace("Character is null but it shouldn't be, waiting");
+            await Task.Delay(50, token).ConfigureAwait(false);
+            totalWaitTime -= 50;
+        }
+        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
+        Dictionary<string, HashSet<string>>? resolvedPaths;
+
+        resolvedPaths = await _ipcManager.Penumbra.GetCharacterData(_logger, playerRelatedObject).ConfigureAwait(false);
+        if (resolvedPaths == null) throw new InvalidOperationException("Penumbra returned null data");
+
+        previousData.FileReplacements[objectKind] =
+                new HashSet<FileReplacement>(resolvedPaths.Select(c => new FileReplacement([.. c.Value], c.Key)), FileReplacementComparer.Instance)
+                .Where(p => p.HasFileReplacement).ToHashSet();
+        previousData.FileReplacements[objectKind].RemoveWhere(c => c.GamePaths.Any(g => !_allowedExtensionsForGamePaths.Any(e => g.EndsWith(e, StringComparison.OrdinalIgnoreCase))));
+
+        _logger.LogDebug("== Static Replacements ==");
+        foreach (var replacement in previousData.FileReplacements[objectKind].Where(i => i.HasFileReplacement).OrderBy(i => i.GamePaths.First(), StringComparer.OrdinalIgnoreCase))
+        {
+            _logger.LogDebug("=> {repl}", replacement);
+        }
+
+        // if it's pet then it's summoner, if it's summoner we actually want to keep all filereplacements alive at all times
+        // or we get into redraw city for every change and nothing works properly
+        if (objectKind == ObjectKind.Pet)
+        {
+            foreach (var item in previousData.FileReplacements[objectKind].Where(i => i.HasFileReplacement).SelectMany(p => p.GamePaths))
+            {
+                _logger.LogDebug("Persisting {item}", item);
+                _transientResourceManager.AddSemiTransientResource(objectKind, item);
+            }
+        }
+
+        _logger.LogDebug("Handling transient update for {obj}", playerRelatedObject);
+
+        // remove all potentially gathered paths from the transient resource manager that are resolved through static resolving
+        _transientResourceManager.ClearTransientPaths(playerRelatedObject.Address, previousData.FileReplacements[objectKind].SelectMany(c => c.GamePaths).ToList());
+
+        // get all remaining paths and resolve them
+        var transientPaths = ManageSemiTransientData(objectKind, playerRelatedObject.Address);
+        var resolvedTransientPaths = await GetFileReplacementsFromPaths(transientPaths, new HashSet<string>(StringComparer.Ordinal)).ConfigureAwait(false);
+
+        _logger.LogDebug("== Transient Replacements ==");
+        foreach (var replacement in resolvedTransientPaths.Select(c => new FileReplacement([.. c.Value], c.Key)).OrderBy(f => f.ResolvedPath, StringComparer.Ordinal))
+        {
+            _logger.LogDebug("=> {repl}", replacement);
+            previousData.FileReplacements[objectKind].Add(replacement);
+        }
+
+        // clean up all semi transient resources that don't have any file replacement (aka null resolve)
+        _transientResourceManager.CleanUpSemiTransientResources(objectKind, [.. previousData.FileReplacements[objectKind]]);
+
+        // make sure we only return data that actually has file replacements
+        foreach (var item in previousData.FileReplacements)
+        {
+            previousData.FileReplacements[item.Key] = new HashSet<FileReplacement>(item.Value.Where(v => v.HasFileReplacement).OrderBy(v => v.ResolvedPath, StringComparer.Ordinal), FileReplacementComparer.Instance);
+        }
+
+        // gather up data from ipc
+        previousData.ManipulationString = _ipcManager.Penumbra.GetMetaManipulations();
+        Task<string> getHeelsOffset = _ipcManager.Heels.GetOffsetAsync();
+        Task<string> getGlamourerData = _ipcManager.Glamourer.GetCharacterCustomizationAsync(playerRelatedObject.Address);
+        Task<string?> getCustomizeData = _ipcManager.CustomizePlus.GetScaleAsync(playerRelatedObject.Address);
+        Task<string> getHonorificTitle = _ipcManager.Honorific.GetTitle();
+        previousData.GlamourerString[playerRelatedObject.ObjectKind] = await getGlamourerData.ConfigureAwait(false);
+        _logger.LogDebug("Glamourer is now: {data}", previousData.GlamourerString[playerRelatedObject.ObjectKind]);
+        var customizeScale = await getCustomizeData.ConfigureAwait(false);
+        previousData.CustomizePlusScale[playerRelatedObject.ObjectKind] = customizeScale ?? string.Empty;
+        _logger.LogDebug("Customize is now: {data}", previousData.CustomizePlusScale[playerRelatedObject.ObjectKind]);
+        previousData.HonorificData = await getHonorificTitle.ConfigureAwait(false);
+        _logger.LogDebug("Honorific is now: {data}", previousData.HonorificData);
+        previousData.HeelsData = await getHeelsOffset.ConfigureAwait(false);
+        _logger.LogDebug("Heels is now: {heels}", previousData.HeelsData);
+        if (objectKind == ObjectKind.Player)
+        {
+            previousData.PetNamesData = _ipcManager.PetNames.GetLocalNames();
+            _logger.LogDebug("Pet Nicknames is now: {petnames}", previousData.PetNamesData);
+            previousData.MoodlesData = await _ipcManager.Moodles.GetStatusAsync(playerRelatedObject.Address).ConfigureAwait(false) ?? string.Empty;
+        }
+
+        if (previousData.FileReplacements.TryGetValue(objectKind, out HashSet<FileReplacement>? fileReplacements))
+        {
+            var toCompute = fileReplacements.Where(f => !f.IsFileSwap).ToArray();
+            _logger.LogDebug("Getting Hashes for {amount} Files", toCompute.Length);
+            var computedPaths = _fileCacheManager.GetFileCachesByPaths(toCompute.Select(c => c.ResolvedPath).ToArray());
+            foreach (var file in toCompute)
+            {
+                file.Hash = computedPaths[file.ResolvedPath]?.Hash ?? string.Empty;
+            }
+            var removed = fileReplacements.RemoveWhere(f => !f.IsFileSwap && string.IsNullOrEmpty(f.Hash));
+            if (removed > 0)
+            {
+                _logger.LogDebug("Removed {amount} of invalid files", removed);
+            }
+        }
+
+        if (objectKind == ObjectKind.Player)
+        {
+            try
+            {
+                await VerifyPlayerAnimationBones(boneIndices, previousData, objectKind).ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                _logger.LogWarning(e, "Failed to verify player animations, continuing without further verification");
+            }
+        }
+
+        _logger.LogInformation("Building character data for {obj} took {time}ms", objectKind, TimeSpan.FromTicks(DateTime.UtcNow.Ticks - start.Ticks).TotalMilliseconds);
+
+        return previousData;
+    }
+
+    private async Task VerifyPlayerAnimationBones(Dictionary<string, List<ushort>>? boneIndices, CharacterData previousData, ObjectKind objectKind)
+    {
+        if (boneIndices == null) return;
+
+        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;
+
+        int noValidationFailed = 0;
+        foreach (var file in previousData.FileReplacements[objectKind].Where(f => !f.IsFileSwap && f.GamePaths.First().EndsWith("pap", StringComparison.OrdinalIgnoreCase)).ToList())
+        {
+            var skeletonIndices = await _dalamudUtil.RunOnFrameworkThread(() => _modelAnalyzer.GetBoneIndicesFromPap(file.Hash)).ConfigureAwait(false);
+            bool validationFailed = false;
+            if (skeletonIndices != null)
+            {
+                // 105 is the maximum vanilla skellington spoopy bone index
+                if (skeletonIndices.All(k => k.Value.Max() <= 105))
+                {
+                    _logger.LogTrace("All indices of {path} are <= 105, ignoring", file.ResolvedPath);
+                    continue;
+                }
+
+                _logger.LogDebug("Verifying bone indices for {path}, found {x} skeletons", file.ResolvedPath, skeletonIndices.Count);
+
+                foreach (var boneCount in skeletonIndices.Select(k => k).ToList())
+                {
+                    if (boneCount.Value.Max() > boneIndices.SelectMany(b => b.Value).Max())
+                    {
+                        _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());
+                        validationFailed = true;
+                        break;
+                    }
+                }
+            }
+
+            if (validationFailed)
+            {
+                noValidationFailed++;
+                _logger.LogDebug("Removing {file} from sent file replacements and transient data", file.ResolvedPath);
+                previousData.FileReplacements[objectKind].Remove(file);
+                foreach (var gamePath in file.GamePaths)
+                {
+                    _transientResourceManager.RemoveTransientResource(objectKind, gamePath);
+                }
+            }
+
+        }
+
+        if (noValidationFailed > 0)
+        {
+            _mareMediator.Publish(new NotificationMessage("Invalid Skeleton Setup",
+                $"Your client is attempting to send {noValidationFailed} animation files with invalid bone data. Those animation files have been removed from your sent data. " +
+                $"Verify that you are using the correct skeleton for those animation files (Check /xllog for more information).",
+                NotificationType.Warning, TimeSpan.FromSeconds(10)));
+        }
+    }
+
+    private async Task<IReadOnlyDictionary<string, string[]>> GetFileReplacementsFromPaths(HashSet<string> forwardResolve, HashSet<string> reverseResolve)
+    {
+        var forwardPaths = forwardResolve.ToArray();
+        var reversePaths = reverseResolve.ToArray();
+        Dictionary<string, List<string>> resolvedPaths = new(StringComparer.Ordinal);
+        var (forward, reverse) = await _ipcManager.Penumbra.ResolvePathsAsync(forwardPaths, reversePaths).ConfigureAwait(false);
+        for (int i = 0; i < forwardPaths.Length; i++)
+        {
+            var filePath = forward[i].ToLowerInvariant();
+            if (resolvedPaths.TryGetValue(filePath, out var list))
+            {
+                list.Add(forwardPaths[i].ToLowerInvariant());
+            }
+            else
+            {
+                resolvedPaths[filePath] = [forwardPaths[i].ToLowerInvariant()];
+            }
+        }
+
+        for (int i = 0; i < reversePaths.Length; i++)
+        {
+            var filePath = reversePaths[i].ToLowerInvariant();
+            if (resolvedPaths.TryGetValue(filePath, out var list))
+            {
+                list.AddRange(reverse[i].Select(c => c.ToLowerInvariant()));
+            }
+            else
+            {
+                resolvedPaths[filePath] = new List<string>(reverse[i].Select(c => c.ToLowerInvariant()).ToList());
+            }
+        }
+
+        return resolvedPaths.ToDictionary(k => k.Key, k => k.Value.ToArray(), StringComparer.OrdinalIgnoreCase).AsReadOnly();
+    }
+
+    private HashSet<string> ManageSemiTransientData(ObjectKind objectKind, IntPtr charaPointer)
+    {
+        _transientResourceManager.PersistTransientResources(charaPointer, objectKind);
+
+        HashSet<string> pathsToResolve = new(StringComparer.Ordinal);
+        foreach (var path in _transientResourceManager.GetSemiTransientResources(objectKind).Where(path => !string.IsNullOrEmpty(path)))
+        {
+            pathsToResolve.Add(path);
+        }
+
+        return pathsToResolve;
+    }
+}

MareSynchronos/PlayerData/Handlers/GameObjectHandler.cs

@@ -0,0 +1,487 @@
+using FFXIVClientStructs.FFXIV.Client.Game.Character;
+using FFXIVClientStructs.FFXIV.Client.Graphics.Scene;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using Microsoft.Extensions.Logging;
+using System.Runtime.CompilerServices;
+using static FFXIVClientStructs.FFXIV.Client.Game.Character.DrawDataContainer;
+using ObjectKind = MareSynchronos.API.Data.Enum.ObjectKind;
+
+namespace MareSynchronos.PlayerData.Handlers;
+
+public sealed class GameObjectHandler : DisposableMediatorSubscriberBase
+{
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly Func<IntPtr> _getAddress;
+    private readonly bool _isOwnedObject;
+    private readonly PerformanceCollectorService _performanceCollector;
+    private CancellationTokenSource? _clearCts = new();
+    private Task? _delayedZoningTask;
+    private bool _haltProcessing = false;
+    private bool _ignoreSendAfterRedraw = false;
+    private int _ptrNullCounter = 0;
+    private byte _classJob = 0;
+    private CancellationTokenSource _zoningCts = new();
+
+    public GameObjectHandler(ILogger<GameObjectHandler> logger, PerformanceCollectorService performanceCollector,
+        MareMediator mediator, DalamudUtilService dalamudUtil, ObjectKind objectKind, Func<IntPtr> getAddress, bool ownedObject = true) : base(logger, mediator)
+    {
+        _performanceCollector = performanceCollector;
+        ObjectKind = objectKind;
+        _dalamudUtil = dalamudUtil;
+        _getAddress = () =>
+        {
+            _dalamudUtil.EnsureIsOnFramework();
+            return getAddress.Invoke();
+        };
+        _isOwnedObject = ownedObject;
+        Name = string.Empty;
+
+        if (ownedObject)
+        {
+            Mediator.Subscribe<TransientResourceChangedMessage>(this, (msg) =>
+            {
+                if (_delayedZoningTask?.IsCompleted ?? true)
+                {
+                    if (msg.Address != Address) return;
+                    Mediator.Publish(new CreateCacheForObjectMessage(this));
+                }
+            });
+        }
+
+        Mediator.Subscribe<FrameworkUpdateMessage>(this, (_) => FrameworkUpdate());
+
+        Mediator.Subscribe<ZoneSwitchEndMessage>(this, (_) => ZoneSwitchEnd());
+        Mediator.Subscribe<ZoneSwitchStartMessage>(this, (_) => ZoneSwitchStart());
+
+        Mediator.Subscribe<CutsceneStartMessage>(this, (_) =>
+        {
+            _haltProcessing = true;
+        });
+        Mediator.Subscribe<CutsceneEndMessage>(this, (_) =>
+        {
+            _haltProcessing = false;
+            ZoneSwitchEnd();
+        });
+        Mediator.Subscribe<PenumbraStartRedrawMessage>(this, (msg) =>
+        {
+            if (msg.Address == Address)
+            {
+                _haltProcessing = true;
+            }
+        });
+        Mediator.Subscribe<PenumbraEndRedrawMessage>(this, (msg) =>
+        {
+            if (msg.Address == Address)
+            {
+                _haltProcessing = false;
+                _ = Task.Run(async () =>
+                {
+                    _ignoreSendAfterRedraw = true;
+                    await Task.Delay(500).ConfigureAwait(false);
+                    _ignoreSendAfterRedraw = false;
+                });
+            }
+        });
+
+        Mediator.Publish(new GameObjectHandlerCreatedMessage(this, _isOwnedObject));
+
+        _dalamudUtil.RunOnFrameworkThread(CheckAndUpdateObject).GetAwaiter().GetResult();
+    }
+
+    private enum DrawCondition
+    {
+        None,
+        DrawObjectZero,
+        RenderFlags,
+        ModelInSlotLoaded,
+        ModelFilesInSlotLoaded
+    }
+
+    public byte RaceId { get; private set; }
+    public byte Gender { get; private set; }
+    public byte TribeId { get; private set; }
+
+    public IntPtr Address { get; private set; }
+    public string Name { get; private set; }
+    public ObjectKind ObjectKind { get; }
+    private byte[] CustomizeData { get; set; } = new byte[26];
+    private IntPtr DrawObjectAddress { get; set; }
+    private byte[] EquipSlotData { get; set; } = new byte[40];
+    private ushort[] MainHandData { get; set; } = new ushort[3];
+    private ushort[] OffHandData { get; set; } = new ushort[3];
+
+    public async Task ActOnFrameworkAfterEnsureNoDrawAsync(Action<Dalamud.Game.ClientState.Objects.Types.ICharacter> act, CancellationToken token)
+    {
+        while (await _dalamudUtil.RunOnFrameworkThread(() =>
+               {
+                   if (IsBeingDrawn()) return true;
+                   var gameObj = _dalamudUtil.CreateGameObject(Address);
+                   if (gameObj is Dalamud.Game.ClientState.Objects.Types.ICharacter chara)
+                   {
+                       act.Invoke(chara);
+                   }
+                   return false;
+               }).ConfigureAwait(false))
+        {
+            await Task.Delay(250, token).ConfigureAwait(false);
+        }
+    }
+
+    public void CompareNameAndThrow(string name)
+    {
+        if (!string.Equals(Name, name, StringComparison.OrdinalIgnoreCase))
+        {
+            throw new InvalidOperationException("Player name not equal to requested name, pointer invalid");
+        }
+        if (Address == IntPtr.Zero)
+        {
+            throw new InvalidOperationException("Player pointer is zero, pointer invalid");
+        }
+    }
+
+    public IntPtr CurrentAddress()
+    {
+        _dalamudUtil.EnsureIsOnFramework();
+        return _getAddress.Invoke();
+    }
+
+    public Dalamud.Game.ClientState.Objects.Types.IGameObject? GetGameObject()
+    {
+        return _dalamudUtil.CreateGameObject(Address);
+    }
+
+    public void Invalidate()
+    {
+        Address = IntPtr.Zero;
+        DrawObjectAddress = IntPtr.Zero;
+        _haltProcessing = false;
+    }
+
+    public async Task<bool> IsBeingDrawnRunOnFrameworkAsync()
+    {
+        return await _dalamudUtil.RunOnFrameworkThread(IsBeingDrawn).ConfigureAwait(false);
+    }
+
+    public override string ToString()
+    {
+        var owned = _isOwnedObject ? "Self" : "Other";
+        return $"{owned}/{ObjectKind}:{Name} ({Address:X},{DrawObjectAddress:X})";
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        Mediator.Publish(new GameObjectHandlerDestroyedMessage(this, _isOwnedObject));
+    }
+
+    private unsafe void CheckAndUpdateObject()
+    {
+        var prevAddr = Address;
+        var prevDrawObj = DrawObjectAddress;
+
+        Address = _getAddress();
+        if (Address != IntPtr.Zero)
+        {
+            _ptrNullCounter = 0;
+            var drawObjAddr = (IntPtr)((FFXIVClientStructs.FFXIV.Client.Game.Object.GameObject*)Address)->DrawObject;
+            DrawObjectAddress = drawObjAddr;
+        }
+        else
+        {
+            DrawObjectAddress = IntPtr.Zero;
+        }
+
+        if (_haltProcessing) return;
+
+        bool drawObjDiff = DrawObjectAddress != prevDrawObj;
+        bool addrDiff = Address != prevAddr;
+
+        if (Address != IntPtr.Zero && DrawObjectAddress != IntPtr.Zero)
+        {
+            if (_clearCts != null)
+            {
+                Logger.LogDebug("[{this}] Cancelling Clear Task", this);
+                _clearCts.CancelDispose();
+                _clearCts = null;
+            }
+            var chara = (Character*)Address;
+            var name = chara->GameObject.NameString;
+            bool nameChange = !string.Equals(name, Name, StringComparison.Ordinal);
+            if (nameChange)
+            {
+                Name = name;
+            }
+            bool equipDiff = false;
+
+            if (((DrawObject*)DrawObjectAddress)->Object.GetObjectType() == ObjectType.CharacterBase
+                && ((CharacterBase*)DrawObjectAddress)->GetModelType() == CharacterBase.ModelType.Human)
+            {
+                var classJob = chara->CharacterData.ClassJob;
+                if (classJob != _classJob)
+                {
+                    Logger.LogTrace("[{this}] classjob changed from {old} to {new}", this, _classJob, classJob);
+                    _classJob = classJob;
+                    Mediator.Publish(new ClassJobChangedMessage(this));
+                }
+
+                equipDiff = CompareAndUpdateEquipByteData((byte*)&((Human*)DrawObjectAddress)->Head);
+
+                ref var mh = ref chara->DrawData.Weapon(WeaponSlot.MainHand);
+                ref var oh = ref chara->DrawData.Weapon(WeaponSlot.OffHand);
+                equipDiff |= CompareAndUpdateMainHand((Weapon*)mh.DrawObject);
+                equipDiff |= CompareAndUpdateOffHand((Weapon*)oh.DrawObject);
+
+                if (equipDiff)
+                    Logger.LogTrace("Checking [{this}] equip data as human from draw obj, result: {diff}", this, equipDiff);
+            }
+            else
+            {
+                equipDiff = CompareAndUpdateEquipByteData((byte*)Unsafe.AsPointer(ref chara->DrawData.EquipmentModelIds[0]));
+                if (equipDiff)
+                    Logger.LogTrace("Checking [{this}] equip data from game obj, result: {diff}", this, equipDiff);
+            }
+
+            if (equipDiff && !_isOwnedObject && !_ignoreSendAfterRedraw) // send the message out immediately and cancel out, no reason to continue if not self
+            {
+                Logger.LogTrace("[{this}] Changed", this);
+                Mediator.Publish(new CharacterChangedMessage(this));
+                return;
+            }
+
+            bool customizeDiff = false;
+
+            if (((DrawObject*)DrawObjectAddress)->Object.GetObjectType() == ObjectType.CharacterBase
+                && ((CharacterBase*)DrawObjectAddress)->GetModelType() == CharacterBase.ModelType.Human)
+            {
+                var gender = ((Human*)DrawObjectAddress)->Customize.Sex;
+                var raceId = ((Human*)DrawObjectAddress)->Customize.Race;
+                var tribeId = ((Human*)DrawObjectAddress)->Customize.Tribe;
+
+                if (_isOwnedObject && ObjectKind == ObjectKind.Player
+                    && (gender != Gender || raceId != RaceId || tribeId != TribeId))
+                {
+                    Mediator.Publish(new CensusUpdateMessage(gender, raceId, tribeId));
+                    Gender = gender;
+                    RaceId = raceId;
+                    TribeId = tribeId;
+                }
+
+                customizeDiff = CompareAndUpdateCustomizeData(((Human*)DrawObjectAddress)->Customize.Data);
+                if (customizeDiff)
+                    Logger.LogTrace("Checking [{this}] customize data as human from draw obj, result: {diff}", this, customizeDiff);
+            }
+            else
+            {
+                customizeDiff = CompareAndUpdateCustomizeData(chara->DrawData.CustomizeData.Data);
+                if (customizeDiff)
+                    Logger.LogTrace("Checking [{this}] customize data from game obj, result: {diff}", this, equipDiff);
+            }
+
+            if ((addrDiff || drawObjDiff || equipDiff || customizeDiff || nameChange) && _isOwnedObject)
+            {
+                Logger.LogDebug("[{this}] Changed, Sending CreateCacheObjectMessage", this);
+                Mediator.Publish(new CreateCacheForObjectMessage(this));
+            }
+        }
+        else if (addrDiff || drawObjDiff)
+        {
+            Logger.LogTrace("[{this}] Changed", this);
+            if (_isOwnedObject && ObjectKind != ObjectKind.Player)
+            {
+                _clearCts?.CancelDispose();
+                _clearCts = new();
+                var token = _clearCts.Token;
+                _ = Task.Run(() => ClearAsync(token), token);
+            }
+        }
+    }
+
+    private async Task ClearAsync(CancellationToken token)
+    {
+        Logger.LogDebug("[{this}] Running Clear Task", this);
+        await Task.Delay(TimeSpan.FromSeconds(1), token).ConfigureAwait(false);
+        Logger.LogDebug("[{this}] Sending ClearCachedForObjectMessage", this);
+        Mediator.Publish(new ClearCacheForObjectMessage(this));
+        _clearCts = null;
+    }
+
+    private unsafe bool CompareAndUpdateCustomizeData(Span<byte> customizeData)
+    {
+        bool hasChanges = false;
+
+        for (int i = 0; i < customizeData.Length; i++)
+        {
+            var data = customizeData[i];
+            if (CustomizeData[i] != data)
+            {
+                CustomizeData[i] = data;
+                hasChanges = true;
+            }
+        }
+
+        return hasChanges;
+    }
+
+    private unsafe bool CompareAndUpdateEquipByteData(byte* equipSlotData)
+    {
+        bool hasChanges = false;
+        for (int i = 0; i < EquipSlotData.Length; i++)
+        {
+            var data = equipSlotData[i];
+            if (EquipSlotData[i] != data)
+            {
+                EquipSlotData[i] = data;
+                hasChanges = true;
+            }
+        }
+
+        return hasChanges;
+    }
+
+    private unsafe bool CompareAndUpdateMainHand(Weapon* weapon)
+    {
+        if ((nint)weapon == nint.Zero) return false;
+        bool hasChanges = false;
+        hasChanges |= weapon->ModelSetId != MainHandData[0];
+        MainHandData[0] = weapon->ModelSetId;
+        hasChanges |= weapon->Variant != MainHandData[1];
+        MainHandData[1] = weapon->Variant;
+        hasChanges |= weapon->SecondaryId != MainHandData[2];
+        MainHandData[2] = weapon->SecondaryId;
+        return hasChanges;
+    }
+
+    private unsafe bool CompareAndUpdateOffHand(Weapon* weapon)
+    {
+        if ((nint)weapon == nint.Zero) return false;
+        bool hasChanges = false;
+        hasChanges |= weapon->ModelSetId != OffHandData[0];
+        OffHandData[0] = weapon->ModelSetId;
+        hasChanges |= weapon->Variant != OffHandData[1];
+        OffHandData[1] = weapon->Variant;
+        hasChanges |= weapon->SecondaryId != OffHandData[2];
+        OffHandData[2] = weapon->SecondaryId;
+        return hasChanges;
+    }
+
+    private void FrameworkUpdate()
+    {
+        if (!_delayedZoningTask?.IsCompleted ?? false) return;
+
+        try
+        {
+            _performanceCollector.LogPerformance(this, $"CheckAndUpdateObject>{(_isOwnedObject ? "Self" : "Other")}+{ObjectKind}/{(string.IsNullOrEmpty(Name) ? "Unk" : Name)}"
+                + $"+{Address.ToString("X")}", CheckAndUpdateObject);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Error during FrameworkUpdate of {this}", this);
+        }
+    }
+
+    private unsafe IntPtr GetDrawObjUnsafe(nint curPtr)
+    {
+        return (IntPtr)((FFXIVClientStructs.FFXIV.Client.Game.Object.GameObject*)curPtr)->DrawObject;
+    }
+
+    private bool IsBeingDrawn()
+    {
+        var curPtr = _getAddress();
+        Logger.LogTrace("[{this}] IsBeingDrawn, CurPtr: {ptr}", this, curPtr.ToString("X"));
+
+        if (curPtr == IntPtr.Zero && _ptrNullCounter < 2)
+        {
+            Logger.LogTrace("[{this}] IsBeingDrawn, CurPtr is ZERO, counter is {cnt}", this, _ptrNullCounter);
+            _ptrNullCounter++;
+            return true;
+        }
+
+        if (curPtr == IntPtr.Zero)
+        {
+            Logger.LogTrace("[{this}] IsBeingDrawn, CurPtr is ZERO, returning", this);
+
+            Address = IntPtr.Zero;
+            DrawObjectAddress = IntPtr.Zero;
+            throw new ArgumentNullException($"CurPtr for {this} turned ZERO");
+        }
+
+        if (_dalamudUtil.IsAnythingDrawing)
+        {
+            Logger.LogTrace("[{this}] IsBeingDrawn, Global draw block", this);
+            return true;
+        }
+
+        var drawObj = GetDrawObjUnsafe(curPtr);
+        Logger.LogTrace("[{this}] IsBeingDrawn, DrawObjPtr: {ptr}", this, drawObj.ToString("X"));
+        var isDrawn = IsBeingDrawnUnsafe(drawObj, curPtr);
+        Logger.LogTrace("[{this}] IsBeingDrawn, Condition: {cond}", this, isDrawn);
+        return isDrawn != DrawCondition.None;
+    }
+
+    private unsafe DrawCondition IsBeingDrawnUnsafe(IntPtr drawObj, IntPtr curPtr)
+    {
+        var drawObjZero = drawObj == IntPtr.Zero;
+        if (drawObjZero) return DrawCondition.DrawObjectZero;
+        var renderFlags = (((FFXIVClientStructs.FFXIV.Client.Game.Object.GameObject*)curPtr)->RenderFlags) != 0x0;
+        if (renderFlags) return DrawCondition.RenderFlags;
+
+        if (ObjectKind == ObjectKind.Player)
+        {
+            var modelInSlotLoaded = (((CharacterBase*)drawObj)->HasModelInSlotLoaded != 0);
+            if (modelInSlotLoaded) return DrawCondition.ModelInSlotLoaded;
+            var modelFilesInSlotLoaded = (((CharacterBase*)drawObj)->HasModelFilesInSlotLoaded != 0);
+            if (modelFilesInSlotLoaded) return DrawCondition.ModelFilesInSlotLoaded;
+            return DrawCondition.None;
+        }
+
+        return DrawCondition.None;
+    }
+
+    private void ZoneSwitchEnd()
+    {
+        if (!_isOwnedObject || _haltProcessing) return;
+
+        _clearCts?.Cancel();
+        _clearCts?.Dispose();
+        _clearCts = null;
+        try
+        {
+            _zoningCts?.CancelAfter(2500);
+        }
+        catch (ObjectDisposedException)
+        {
+            // ignore
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Zoning CTS cancel issue");
+        }
+    }
+
+    private void ZoneSwitchStart()
+    {
+        if (!_isOwnedObject || _haltProcessing) return;
+
+        _zoningCts = new();
+        Logger.LogDebug("[{obj}] Starting Delay After Zoning", this);
+        _delayedZoningTask = Task.Run(async () =>
+        {
+            try
+            {
+                await Task.Delay(TimeSpan.FromSeconds(120), _zoningCts.Token).ConfigureAwait(false);
+            }
+            catch
+            {
+                // ignore cancelled
+            }
+            finally
+            {
+                Logger.LogDebug("[{this}] Delay after zoning complete", this);
+                _zoningCts.Dispose();
+            }
+        });
+    }
+}

MareSynchronos/PlayerData/Handlers/PairHandler.cs

@@ -0,0 +1,916 @@
+using MareSynchronos.API.Data;
+using MareSynchronos.FileCache;
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Factories;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Events;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using MareSynchronos.Utils;
+using MareSynchronos.WebAPI.Files;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using ObjectKind = MareSynchronos.API.Data.Enum.ObjectKind;
+
+namespace MareSynchronos.PlayerData.Handlers;
+
+public sealed class PairHandler : DisposableMediatorSubscriberBase
+{
+    private sealed record CombatData(Guid ApplicationId, CharacterData CharacterData, bool Forced);
+
+    private readonly MareConfigService _configService;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly FileDownloadManager _downloadManager;
+    private readonly FileCacheManager _fileDbManager;
+    private readonly GameObjectHandlerFactory _gameObjectHandlerFactory;
+    private readonly IpcManager _ipcManager;
+    private readonly PlayerPerformanceService _playerPerformanceService;
+    private readonly ServerConfigurationManager _serverConfigManager;
+    private readonly PluginWarningNotificationService _pluginWarningNotificationManager;
+    private readonly VisibilityService _visibilityService;
+    private readonly NoSnapService _noSnapService;
+    private CancellationTokenSource? _applicationCancellationTokenSource = new();
+    private Guid _applicationId;
+    private Task? _applicationTask;
+    private CharacterData? _cachedData = null;
+    private GameObjectHandler? _charaHandler;
+    private readonly Dictionary<ObjectKind, Guid?> _customizeIds = [];
+    private CombatData? _dataReceivedInDowntime;
+    private CancellationTokenSource? _downloadCancellationTokenSource = new();
+    private bool _forceApplyMods = false;
+    private bool _isVisible;
+    private Guid _deferred = Guid.Empty;
+    private Guid _penumbraCollection = Guid.Empty;
+    private bool _redrawOnNextApplication = false;
+
+    public PairHandler(ILogger<PairHandler> logger, Pair pair, PairAnalyzer pairAnalyzer,
+        GameObjectHandlerFactory gameObjectHandlerFactory,
+        IpcManager ipcManager, FileDownloadManager transferManager,
+        PluginWarningNotificationService pluginWarningNotificationManager,
+        DalamudUtilService dalamudUtil, IHostApplicationLifetime lifetime,
+        FileCacheManager fileDbManager, MareMediator mediator,
+        PlayerPerformanceService playerPerformanceService,
+        ServerConfigurationManager serverConfigManager,
+        MareConfigService configService, VisibilityService visibilityService,
+        NoSnapService noSnapService) : base(logger, mediator)
+    {
+        Pair = pair;
+        PairAnalyzer = pairAnalyzer;
+        _gameObjectHandlerFactory = gameObjectHandlerFactory;
+        _ipcManager = ipcManager;
+        _downloadManager = transferManager;
+        _pluginWarningNotificationManager = pluginWarningNotificationManager;
+        _dalamudUtil = dalamudUtil;
+        _fileDbManager = fileDbManager;
+        _playerPerformanceService = playerPerformanceService;
+        _serverConfigManager = serverConfigManager;
+        _configService = configService;
+        _visibilityService = visibilityService;
+        _noSnapService = noSnapService;
+
+        _visibilityService.StartTracking(Pair.Ident);
+
+        Mediator.SubscribeKeyed<PlayerVisibilityMessage>(this, Pair.Ident, (msg) => UpdateVisibility(msg.IsVisible, msg.Invalidate));
+
+        Mediator.Subscribe<ZoneSwitchStartMessage>(this, (_) =>
+        {
+            _downloadCancellationTokenSource?.CancelDispose();
+            _charaHandler?.Invalidate();
+            IsVisible = false;
+        });
+        Mediator.Subscribe<PenumbraInitializedMessage>(this, (_) =>
+        {
+            _penumbraCollection = Guid.Empty;
+            if (!IsVisible && _charaHandler != null)
+            {
+                PlayerName = string.Empty;
+                _charaHandler.Dispose();
+                _charaHandler = null;
+            }
+        });
+        Mediator.Subscribe<ClassJobChangedMessage>(this, (msg) =>
+        {
+            if (msg.GameObjectHandler == _charaHandler)
+            {
+                _redrawOnNextApplication = true;
+            }
+        });
+        Mediator.Subscribe<CombatOrPerformanceEndMessage>(this, (msg) =>
+        {
+            if (IsVisible && _dataReceivedInDowntime != null)
+            {
+                ApplyCharacterData(_dataReceivedInDowntime.ApplicationId,
+                    _dataReceivedInDowntime.CharacterData, _dataReceivedInDowntime.Forced);
+                _dataReceivedInDowntime = null;
+            }
+        });
+        Mediator.Subscribe<CombatOrPerformanceStartMessage>(this, _ =>
+        {
+            if (_configService.Current.HoldCombatApplication)
+            {
+                _dataReceivedInDowntime = null;
+                _downloadCancellationTokenSource = _downloadCancellationTokenSource?.CancelRecreate();
+                _applicationCancellationTokenSource = _applicationCancellationTokenSource?.CancelRecreate();
+            }
+        });
+        Mediator.Subscribe<RecalculatePerformanceMessage>(this, (msg) =>
+        {
+            if (msg.UID != null && !msg.UID.Equals(Pair.UserData.UID, StringComparison.Ordinal)) return;
+            Logger.LogDebug("Recalculating performance for {uid}", Pair.UserData.UID);
+            pair.ApplyLastReceivedData(forced: true);
+        });
+
+        LastAppliedDataBytes = -1;
+    }
+
+    public bool IsVisible
+    {
+        get => _isVisible;
+        private set
+        {
+            if (_isVisible != value)
+            {
+                _isVisible = value;
+                string text = "User Visibility Changed, now: " + (_isVisible ? "Is Visible" : "Is not Visible");
+                Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler),
+                    EventSeverity.Informational, text)));
+            }
+        }
+    }
+
+    public long LastAppliedDataBytes { get; private set; }
+    public Pair Pair { get; private init; }
+    public PairAnalyzer PairAnalyzer { get; private init; }
+    public nint PlayerCharacter => _charaHandler?.Address ?? nint.Zero;
+    public unsafe uint PlayerCharacterId => (_charaHandler?.Address ?? nint.Zero) == nint.Zero
+        ? uint.MaxValue
+        : ((FFXIVClientStructs.FFXIV.Client.Game.Object.GameObject*)_charaHandler!.Address)->EntityId;
+    public string? PlayerName { get; private set; }
+    public string PlayerNameHash => Pair.Ident;
+
+    public void ApplyCharacterData(Guid applicationBase, CharacterData characterData, bool forceApplyCustomization = false)
+    {
+        if (_configService.Current.HoldCombatApplication && _dalamudUtil.IsInCombatOrPerforming)
+        {
+            Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler), EventSeverity.Warning,
+                "Cannot apply character data: you are in combat or performing music, deferring application")));
+            Logger.LogDebug("[BASE-{appBase}] Received data but player is in combat or performing", applicationBase);
+            _dataReceivedInDowntime = new(applicationBase, characterData, forceApplyCustomization);
+            SetUploading(isUploading: false);
+            return;
+        }
+
+        if (_charaHandler == null || (PlayerCharacter == IntPtr.Zero))
+        {
+            if (_deferred != Guid.Empty)
+            {
+                _isVisible = false;
+                _visibilityService.StopTracking(Pair.Ident);
+                _visibilityService.StartTracking(Pair.Ident);
+            }
+
+            Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler), EventSeverity.Warning,
+                "Cannot apply character data: Receiving Player is in an invalid state, deferring application")));
+            Logger.LogDebug("[BASE-{appBase}] Received data but player was in invalid state, charaHandlerIsNull: {charaIsNull}, playerPointerIsNull: {ptrIsNull}",
+                applicationBase, _charaHandler == null, PlayerCharacter == IntPtr.Zero);
+            var hasDiffMods = characterData.CheckUpdatedData(applicationBase, _cachedData, Logger,
+                this, forceApplyCustomization, forceApplyMods: false)
+                .Any(p => p.Value.Contains(PlayerChanges.ModManip) || p.Value.Contains(PlayerChanges.ModFiles));
+            _forceApplyMods = hasDiffMods || _forceApplyMods || (PlayerCharacter == IntPtr.Zero && _cachedData == null);
+            _cachedData = characterData;
+            Mediator.Publish(new PairDataAppliedMessage(Pair.UserData.UID, characterData));
+            Logger.LogDebug("[BASE-{appBase}] Setting data: {hash}, forceApplyMods: {force}", applicationBase, _cachedData.DataHash.Value, _forceApplyMods);
+            // Ensure that this deferred application actually occurs by forcing visibiltiy to re-proc
+            // Set _deferred as a silencing flag to avoid spamming logs once per frame with failed applications
+            _isVisible = false;
+            _deferred = applicationBase;
+            _visibilityService.StopTracking(Pair.Ident);
+            _visibilityService.StartTracking(Pair.Ident);
+            return;
+        }
+
+        _deferred = Guid.Empty;
+
+        SetUploading(isUploading: false);
+
+        if (Pair.IsDownloadBlocked)
+        {
+            var reasons = string.Join(", ", Pair.HoldDownloadReasons);
+            Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler), EventSeverity.Warning,
+                $"Not applying character data: {reasons}")));
+            Logger.LogDebug("[BASE-{appBase}] Not applying due to hold: {reasons}", applicationBase, reasons);
+            var hasDiffMods = characterData.CheckUpdatedData(applicationBase, _cachedData, Logger,
+                this, forceApplyCustomization, forceApplyMods: false)
+                .Any(p => p.Value.Contains(PlayerChanges.ModManip) || p.Value.Contains(PlayerChanges.ModFiles));
+            _forceApplyMods = hasDiffMods || _forceApplyMods || (PlayerCharacter == IntPtr.Zero && _cachedData == null);
+            _cachedData = characterData;
+            Mediator.Publish(new PairDataAppliedMessage(Pair.UserData.UID, characterData));
+            Logger.LogDebug("[BASE-{appBase}] Setting data: {hash}, forceApplyMods: {force}", applicationBase, _cachedData.DataHash.Value, _forceApplyMods);
+            return;
+        }
+
+        Logger.LogDebug("[BASE-{appbase}] Applying data for {player}, forceApplyCustomization: {forced}, forceApplyMods: {forceMods}", applicationBase, this, forceApplyCustomization, _forceApplyMods);
+        Logger.LogDebug("[BASE-{appbase}] Hash for data is {newHash}, current cache hash is {oldHash}", applicationBase, characterData.DataHash.Value, _cachedData?.DataHash.Value ?? "NODATA");
+
+        if (string.Equals(characterData.DataHash.Value, _cachedData?.DataHash.Value ?? string.Empty, StringComparison.Ordinal) && !forceApplyCustomization) return;
+
+        if (_dalamudUtil.IsInCutscene || _dalamudUtil.IsInGpose || !_ipcManager.Penumbra.APIAvailable || !_ipcManager.Glamourer.APIAvailable)
+        {
+            Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler), EventSeverity.Warning,
+                "Cannot apply character data: you are in GPose, a Cutscene or Penumbra/Glamourer is not available")));
+            Logger.LogInformation("[BASE-{appbase}] Application of data for {player} while in cutscene/gpose or Penumbra/Glamourer unavailable, returning", applicationBase, this);
+            return;
+        }
+
+        Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler), EventSeverity.Informational,
+            "Applying Character Data")));
+
+        _forceApplyMods |= forceApplyCustomization;
+
+        var charaDataToUpdate = characterData.CheckUpdatedData(applicationBase, _cachedData?.DeepClone() ?? new(), Logger, this, forceApplyCustomization, _forceApplyMods);
+
+        if (_charaHandler != null && _forceApplyMods)
+        {
+            _forceApplyMods = false;
+        }
+
+        if (_redrawOnNextApplication && charaDataToUpdate.TryGetValue(ObjectKind.Player, out var player))
+        {
+            player.Add(PlayerChanges.ForcedRedraw);
+            _redrawOnNextApplication = false;
+        }
+
+        if (charaDataToUpdate.TryGetValue(ObjectKind.Player, out var playerChanges))
+        {
+            _pluginWarningNotificationManager.NotifyForMissingPlugins(Pair.UserData, PlayerName!, playerChanges);
+        }
+
+        Logger.LogDebug("[BASE-{appbase}] Downloading and applying character for {name}", applicationBase, this);
+
+        DownloadAndApplyCharacter(applicationBase, characterData.DeepClone(), charaDataToUpdate);
+    }
+
+    public override string ToString()
+    {
+        return Pair == null
+            ? base.ToString() ?? string.Empty
+            : Pair.UserData.AliasOrUID + ":" + PlayerName + ":" + (PlayerCharacter != nint.Zero ? "HasChar" : "NoChar");
+    }
+
+    internal void SetUploading(bool isUploading = true)
+    {
+        Logger.LogTrace("Setting {this} uploading {uploading}", this, isUploading);
+        if (_charaHandler != null)
+        {
+            Mediator.Publish(new PlayerUploadingMessage(_charaHandler, isUploading));
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        if (!disposing) return;
+
+        _visibilityService.StopTracking(Pair.Ident);
+
+        SetUploading(isUploading: false);
+        var name = PlayerName;
+        Logger.LogDebug("Disposing {name} ({user})", name, Pair);
+        try
+        {
+            Guid applicationId = Guid.NewGuid();
+
+            if (!string.IsNullOrEmpty(name))
+            {
+                Mediator.Publish(new EventMessage(new Event(name, Pair.UserData, nameof(PairHandler), EventSeverity.Informational, "Disposing User")));
+            }
+
+            UndoApplicationAsync(applicationId).GetAwaiter().GetResult();
+
+            _applicationCancellationTokenSource?.Dispose();
+            _applicationCancellationTokenSource = null;
+            _downloadCancellationTokenSource?.Dispose();
+            _downloadCancellationTokenSource = null;
+            _charaHandler?.Dispose();
+            _charaHandler = null;
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Error on disposal of {name}", name);
+        }
+        finally
+        {
+            PlayerName = null;
+            _cachedData = null;
+            Mediator.Publish(new PairDataAppliedMessage(Pair.UserData.UID, null));
+            Logger.LogDebug("Disposing {name} complete", name);
+        }
+    }
+
+    public void UndoApplication(Guid applicationId = default)
+    {
+        _ = Task.Run(async () => {
+            await UndoApplicationAsync(applicationId).ConfigureAwait(false);
+        });
+    }
+
+    private void RegisterGposeClones()
+    {
+        var name = PlayerName;
+        if (name == null)
+            return;
+        _ = _dalamudUtil.RunOnFrameworkThread(() =>
+        {
+            foreach (var actor in _dalamudUtil.GetGposeCharactersFromObjectTable())
+            {
+                if (actor == null) continue;
+                var gposeName = actor.Name.TextValue;
+                if (!name.Equals(gposeName, StringComparison.Ordinal))
+                    continue;
+                _noSnapService.AddGposer(actor.ObjectIndex);
+            }
+        });
+    }
+
+    private async Task UndoApplicationAsync(Guid applicationId = default)
+    {
+        Logger.LogDebug($"Undoing application of {Pair.UserPair}");
+        var name = PlayerName;
+        try
+        {
+            if (applicationId == default)
+                applicationId = Guid.NewGuid();
+            _applicationCancellationTokenSource = _applicationCancellationTokenSource?.CancelRecreate();
+            _downloadCancellationTokenSource = _downloadCancellationTokenSource?.CancelRecreate();
+
+            Logger.LogDebug("[{applicationId}] Removing Temp Collection for {name} ({user})", applicationId, name, Pair.UserPair);
+            if (_penumbraCollection != Guid.Empty)
+            {
+                await _ipcManager.Penumbra.RemoveTemporaryCollectionAsync(Logger, applicationId, _penumbraCollection).ConfigureAwait(false);
+                _penumbraCollection = Guid.Empty;
+                RegisterGposeClones();
+            }
+
+            if (_dalamudUtil is { IsZoning: false, IsInCutscene: false } && !string.IsNullOrEmpty(name))
+            {
+                Logger.LogTrace("[{applicationId}] Restoring state for {name} ({OnlineUser})", applicationId, name, Pair.UserPair);
+                if (!IsVisible)
+                {
+                    Logger.LogDebug("[{applicationId}] Restoring Glamourer for {name} ({user})", applicationId, name, Pair.UserPair);
+                    await _ipcManager.Glamourer.RevertByNameAsync(Logger, name, applicationId).ConfigureAwait(false);
+                }
+                else
+                {
+                    using var cts = new CancellationTokenSource();
+                    cts.CancelAfter(TimeSpan.FromSeconds(60));
+
+                    Logger.LogInformation("[{applicationId}] CachedData is null {isNull}, contains things: {contains}", applicationId, _cachedData == null, _cachedData?.FileReplacements.Any() ?? false);
+
+                    foreach (KeyValuePair<ObjectKind, List<FileReplacementData>> item in _cachedData?.FileReplacements ?? [])
+                    {
+                        try
+                        {
+                            await RevertCustomizationDataAsync(item.Key, name, applicationId, cts.Token).ConfigureAwait(false);
+                        }
+                        catch (InvalidOperationException ex)
+                        {
+                            Logger.LogWarning(ex, "Failed disposing player (not present anymore?)");
+                            break;
+                        }
+                    }
+                }
+            }
+            else if (_dalamudUtil.IsInCutscene && !string.IsNullOrEmpty(name))
+            {
+                _noSnapService.AddGposerNamed(name);
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Error on undoing application of {name}", name);
+        }
+    }
+
+    private async Task ApplyCustomizationDataAsync(Guid applicationId, KeyValuePair<ObjectKind, HashSet<PlayerChanges>> changes, CharacterData charaData, CancellationToken token)
+    {
+        if (PlayerCharacter == nint.Zero) return;
+        var ptr = PlayerCharacter;
+
+        var handler = changes.Key switch
+        {
+            ObjectKind.Player => _charaHandler!,
+            ObjectKind.Companion => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetCompanion(ptr), isWatched: false).ConfigureAwait(false),
+            ObjectKind.MinionOrMount => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetMinionOrMount(ptr), isWatched: false).ConfigureAwait(false),
+            ObjectKind.Pet => await _gameObjectHandlerFactory.Create(changes.Key, () => _dalamudUtil.GetPet(ptr), isWatched: false).ConfigureAwait(false),
+            _ => throw new NotSupportedException("ObjectKind not supported: " + changes.Key)
+        };
+
+        async Task processApplication(IEnumerable<PlayerChanges> changeList)
+        {
+            foreach (var change in changeList)
+            {
+                Logger.LogDebug("[{applicationId}{ft}] Processing {change} for {handler}", applicationId, _dalamudUtil.IsOnFrameworkThread ? "*" : "", change, handler);
+                switch (change)
+                {
+                    case PlayerChanges.Customize:
+                        if (charaData.CustomizePlusData.TryGetValue(changes.Key, out var customizePlusData))
+                        {
+                            _customizeIds[changes.Key] = await _ipcManager.CustomizePlus.SetBodyScaleAsync(handler.Address, customizePlusData).ConfigureAwait(false);
+                        }
+                        else if (_customizeIds.TryGetValue(changes.Key, out var customizeId))
+                        {
+                            await _ipcManager.CustomizePlus.RevertByIdAsync(customizeId).ConfigureAwait(false);
+                            _customizeIds.Remove(changes.Key);
+                        }
+                        break;
+
+                    case PlayerChanges.Heels:
+                        await _ipcManager.Heels.SetOffsetForPlayerAsync(handler.Address, charaData.HeelsData).ConfigureAwait(false);
+                        break;
+
+                    case PlayerChanges.Honorific:
+                        await _ipcManager.Honorific.SetTitleAsync(handler.Address, charaData.HonorificData).ConfigureAwait(false);
+                        break;
+
+                    case PlayerChanges.Glamourer:
+                        if (charaData.GlamourerData.TryGetValue(changes.Key, out var glamourerData))
+                        {
+                            await _ipcManager.Glamourer.ApplyAllAsync(Logger, handler, glamourerData, applicationId, token, allowImmediate: true).ConfigureAwait(false);
+                        }
+                        break;
+
+                    case PlayerChanges.PetNames:
+                        await _ipcManager.PetNames.SetPlayerData(handler.Address, charaData.PetNamesData).ConfigureAwait(false);
+                        break;
+
+                    case PlayerChanges.Moodles:
+                        await _ipcManager.Moodles.SetStatusAsync(handler.Address, charaData.MoodlesData).ConfigureAwait(false);
+                        break;
+
+                    case PlayerChanges.ForcedRedraw:
+                        await _ipcManager.Penumbra.RedrawAsync(Logger, handler, applicationId, token).ConfigureAwait(false);
+                        break;
+
+                    default:
+                        break;
+                }
+                token.ThrowIfCancellationRequested();
+            }
+        }
+
+        try
+        {
+            if (handler.Address == nint.Zero)
+            {
+                return;
+            }
+
+            Logger.LogDebug("[{applicationId}] Applying Customization Data for {handler}", applicationId, handler);
+            await _dalamudUtil.WaitWhileCharacterIsDrawing(Logger, handler, applicationId, 30000, token).ConfigureAwait(false);
+            token.ThrowIfCancellationRequested();
+            if (_configService.Current.SerialApplication)
+            {
+                var serialChangeList = changes.Value.Where(p => p <= PlayerChanges.ForcedRedraw).OrderBy(p => (int)p);
+                var asyncChangeList = changes.Value.Where(p => p > PlayerChanges.ForcedRedraw).OrderBy(p => (int)p);
+                await _dalamudUtil.RunOnFrameworkThread(async () => await processApplication(serialChangeList).ConfigureAwait(false)).ConfigureAwait(false);
+                await Task.Run(async () => await processApplication(asyncChangeList).ConfigureAwait(false), CancellationToken.None).ConfigureAwait(false);
+            }
+            else
+            {
+                _ = processApplication(changes.Value.OrderBy(p => (int)p));
+            }
+        }
+        finally
+        {
+            if (handler != _charaHandler) handler.Dispose();
+        }
+    }
+
+    private void DownloadAndApplyCharacter(Guid applicationBase, CharacterData charaData, Dictionary<ObjectKind, HashSet<PlayerChanges>> updatedData)
+    {
+        if (!updatedData.Any())
+        {
+            Logger.LogDebug("[BASE-{appBase}] Nothing to update for {obj}", applicationBase, this);
+            return;
+        }
+
+        var updateModdedPaths = updatedData.Values.Any(v => v.Any(p => p == PlayerChanges.ModFiles));
+        var updateManip = updatedData.Values.Any(v => v.Any(p => p == PlayerChanges.ModManip));
+
+        _downloadCancellationTokenSource = _downloadCancellationTokenSource?.CancelRecreate() ?? new CancellationTokenSource();
+        var downloadToken = _downloadCancellationTokenSource.Token;
+
+        _ = Task.Run(async () => {
+            await DownloadAndApplyCharacterAsync(applicationBase, charaData, updatedData, updateModdedPaths, updateManip, downloadToken).ConfigureAwait(false);
+        });
+    }
+
+    private Task? _pairDownloadTask;
+
+    private async Task DownloadAndApplyCharacterAsync(Guid applicationBase, CharacterData charaData, Dictionary<ObjectKind, HashSet<PlayerChanges>> updatedData,
+        bool updateModdedPaths, bool updateManip, CancellationToken downloadToken)
+    {
+        Logger.LogTrace("[BASE-{appBase}] DownloadAndApplyCharacterAsync", applicationBase);
+        Dictionary<(string GamePath, string? Hash), string> moddedPaths = [];
+
+        if (updateModdedPaths)
+        {
+            Logger.LogTrace("[BASE-{appBase}] DownloadAndApplyCharacterAsync > updateModdedPaths", applicationBase);
+            int attempts = 0;
+            List<FileReplacementData> toDownloadReplacements = TryCalculateModdedDictionary(applicationBase, charaData, out moddedPaths, downloadToken);
+
+            while (toDownloadReplacements.Count > 0 && attempts++ <= 10 && !downloadToken.IsCancellationRequested)
+            {
+                if (_pairDownloadTask != null && !_pairDownloadTask.IsCompleted)
+                {
+                    Logger.LogDebug("[BASE-{appBase}] Finishing prior running download task for player {name}, {kind}", applicationBase, PlayerName, updatedData);
+                    await _pairDownloadTask.ConfigureAwait(false);
+                }
+
+                Logger.LogDebug("[BASE-{appBase}] Downloading missing files for player {name}, {kind}", applicationBase, PlayerName, updatedData);
+
+                Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler), EventSeverity.Informational,
+                    $"Starting download for {toDownloadReplacements.Count} files")));
+                var toDownloadFiles = await _downloadManager.InitiateDownloadList(_charaHandler!, toDownloadReplacements, downloadToken).ConfigureAwait(false);
+
+                if (!_playerPerformanceService.ComputeAndAutoPauseOnVRAMUsageThresholds(this, charaData, toDownloadFiles))
+                {
+                    Pair.HoldApplication("IndividualPerformanceThreshold", maxValue: 1);
+                    _downloadManager.ClearDownload();
+                    return;
+                }
+
+                _pairDownloadTask = Task.Run(async () => await _downloadManager.DownloadFiles(_charaHandler!, toDownloadReplacements, downloadToken).ConfigureAwait(false), downloadToken);
+
+                await _pairDownloadTask.ConfigureAwait(false);
+
+                if (downloadToken.IsCancellationRequested)
+                {
+                    Logger.LogTrace("[BASE-{appBase}] Detected cancellation", applicationBase);
+                    return;
+                }
+
+                toDownloadReplacements = TryCalculateModdedDictionary(applicationBase, charaData, out moddedPaths, downloadToken);
+
+                if (toDownloadReplacements.TrueForAll(c => _downloadManager.ForbiddenTransfers.Exists(f => string.Equals(f.Hash, c.Hash, StringComparison.Ordinal))))
+                {
+                    break;
+                }
+
+                await Task.Delay(TimeSpan.FromSeconds(2), downloadToken).ConfigureAwait(false);
+            }
+
+            try
+            {
+                Mediator.Publish(new HaltScanMessage(nameof(PlayerPerformanceService.ShrinkTextures)));
+                if (await _playerPerformanceService.ShrinkTextures(this, charaData, downloadToken).ConfigureAwait(false))
+                    _ = TryCalculateModdedDictionary(applicationBase, charaData, out moddedPaths, downloadToken);
+            }
+            finally
+            {
+                Mediator.Publish(new ResumeScanMessage(nameof(PlayerPerformanceService.ShrinkTextures)));
+            }
+
+            bool exceedsThreshold = !await _playerPerformanceService.CheckBothThresholds(this, charaData).ConfigureAwait(false);
+
+            if (exceedsThreshold)
+                Pair.HoldApplication("IndividualPerformanceThreshold", maxValue: 1);
+            else
+                Pair.UnholdApplication("IndividualPerformanceThreshold");
+
+            if (exceedsThreshold)
+            {
+                Logger.LogTrace("[BASE-{appBase}] Not applying due to performance thresholds", applicationBase);
+                return;
+            }
+        }
+
+        if (Pair.IsApplicationBlocked)
+        {
+            var reasons = string.Join(", ", Pair.HoldApplicationReasons);
+            Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler), EventSeverity.Warning,
+                $"Not applying character data: {reasons}")));
+            Logger.LogTrace("[BASE-{appBase}] Not applying due to hold: {reasons}", applicationBase, reasons);
+            return;
+        }
+
+        downloadToken.ThrowIfCancellationRequested();
+
+        var appToken = _applicationCancellationTokenSource?.Token;
+        while ((!_applicationTask?.IsCompleted ?? false)
+               && !downloadToken.IsCancellationRequested
+               && (!appToken?.IsCancellationRequested ?? false))
+        {
+            // block until current application is done
+            Logger.LogDebug("[BASE-{appBase}] Waiting for current data application (Id: {id}) for player ({handler}) to finish", applicationBase, _applicationId, PlayerName);
+            await Task.Delay(250).ConfigureAwait(false);
+        }
+
+        if (downloadToken.IsCancellationRequested || (appToken?.IsCancellationRequested ?? false)) return;
+
+        _applicationCancellationTokenSource = _applicationCancellationTokenSource.CancelRecreate() ?? new CancellationTokenSource();
+        var token = _applicationCancellationTokenSource.Token;
+
+        _applicationTask = ApplyCharacterDataAsync(applicationBase, charaData, updatedData, updateModdedPaths, updateManip, moddedPaths, token);
+    }
+
+    private async Task ApplyCharacterDataAsync(Guid applicationBase, CharacterData charaData, Dictionary<ObjectKind, HashSet<PlayerChanges>> updatedData, bool updateModdedPaths, bool updateManip,
+        Dictionary<(string GamePath, string? Hash), string> moddedPaths, CancellationToken token)
+    {
+        ushort objIndex = ushort.MaxValue;
+        try
+        {
+            _applicationId = Guid.NewGuid();
+            Logger.LogDebug("[BASE-{applicationId}] Starting application task for {this}: {appId}", applicationBase, this, _applicationId);
+
+            if (_penumbraCollection == Guid.Empty)
+            {
+                if (objIndex == ushort.MaxValue)
+                    objIndex = await _dalamudUtil.RunOnFrameworkThread(() => _charaHandler!.GetGameObject()!.ObjectIndex).ConfigureAwait(false);
+                _penumbraCollection = await _ipcManager.Penumbra.CreateTemporaryCollectionAsync(Logger, Pair.UserData.UID).ConfigureAwait(false);
+                await _ipcManager.Penumbra.AssignTemporaryCollectionAsync(Logger, _penumbraCollection, objIndex).ConfigureAwait(false);
+            }
+
+            Logger.LogDebug("[{applicationId}] Waiting for initial draw for for {handler}", _applicationId, _charaHandler);
+            await _dalamudUtil.WaitWhileCharacterIsDrawing(Logger, _charaHandler!, _applicationId, 30000, token).ConfigureAwait(false);
+
+            token.ThrowIfCancellationRequested();
+
+            if (updateModdedPaths)
+            {
+                // ensure collection is set
+                if (objIndex == ushort.MaxValue)
+                    objIndex = await _dalamudUtil.RunOnFrameworkThread(() => _charaHandler!.GetGameObject()!.ObjectIndex).ConfigureAwait(false);
+                await _ipcManager.Penumbra.AssignTemporaryCollectionAsync(Logger, _penumbraCollection, objIndex).ConfigureAwait(false);
+
+                await _ipcManager.Penumbra.SetTemporaryModsAsync(Logger, _applicationId, _penumbraCollection,
+                    moddedPaths.ToDictionary(k => k.Key.GamePath, k => k.Value, StringComparer.Ordinal)).ConfigureAwait(false);
+                LastAppliedDataBytes = -1;
+                foreach (var path in moddedPaths.Values.Distinct(StringComparer.OrdinalIgnoreCase).Select(v => new FileInfo(v)).Where(p => p.Exists))
+                {
+                    if (LastAppliedDataBytes == -1) LastAppliedDataBytes = 0;
+
+                    LastAppliedDataBytes += path.Length;
+                }
+            }
+
+            if (updateManip)
+            {
+                await _ipcManager.Penumbra.SetManipulationDataAsync(Logger, _applicationId, _penumbraCollection, charaData.ManipulationData).ConfigureAwait(false);
+            }
+
+            token.ThrowIfCancellationRequested();
+
+            foreach (var kind in updatedData)
+            {
+                await ApplyCustomizationDataAsync(_applicationId, kind, charaData, token).ConfigureAwait(false);
+                token.ThrowIfCancellationRequested();
+            }
+
+            _cachedData = charaData;
+            Mediator.Publish(new PairDataAppliedMessage(Pair.UserData.UID, charaData));
+
+            Logger.LogDebug("[{applicationId}] Application finished", _applicationId);
+        }
+        catch (Exception ex)
+        {
+            if (ex is AggregateException aggr && aggr.InnerExceptions.Any(e => e is ArgumentNullException))
+            {
+                IsVisible = false;
+                _forceApplyMods = true;
+                _cachedData = charaData;
+                Mediator.Publish(new PairDataAppliedMessage(Pair.UserData.UID, charaData));
+                Logger.LogDebug("[{applicationId}] Cancelled, player turned null during application", _applicationId);
+            }
+            else
+            {
+                Logger.LogWarning(ex, "[{applicationId}] Cancelled", _applicationId);
+            }
+        }
+    }
+
+    private void UpdateVisibility(bool nowVisible, bool invalidate = false)
+    {
+        if (string.IsNullOrEmpty(PlayerName))
+        {
+            var pc = _dalamudUtil.FindPlayerByNameHash(Pair.Ident);
+            if (pc.ObjectId == 0) return;
+            Logger.LogDebug("One-Time Initializing {this}", this);
+            Initialize(pc.Name);
+            Logger.LogDebug("One-Time Initialized {this}", this);
+            Mediator.Publish(new EventMessage(new Event(PlayerName, Pair.UserData, nameof(PairHandler), EventSeverity.Informational,
+                $"Initializing User For Character {pc.Name}")));
+        }
+
+        // This was triggered by the character becoming handled by Mare, so unapply everything
+        // There seems to be a good chance that this races Mare and then crashes
+        if (!nowVisible && invalidate)
+        {
+            bool wasVisible = IsVisible;
+            IsVisible = false;
+            _charaHandler?.Invalidate();
+            _downloadCancellationTokenSource?.CancelDispose();
+            _downloadCancellationTokenSource = null;
+            if (wasVisible)
+                Logger.LogTrace("{this} visibility changed, now: {visi}", this, IsVisible);
+            Logger.LogDebug("Invalidating {this}", this);
+            UndoApplication();
+            return;
+        }
+
+        if (!IsVisible && nowVisible)
+        {
+            // This is deferred application attempt, avoid any log output
+            if (_deferred != Guid.Empty)
+            {
+                _isVisible = true;
+                _ = Task.Run(() =>
+                {
+                    ApplyCharacterData(_deferred, _cachedData!, forceApplyCustomization: true);
+                });
+            }
+
+            IsVisible = true;
+            Mediator.Publish(new PairHandlerVisibleMessage(this));
+            if (_cachedData != null)
+            {
+                Guid appData = Guid.NewGuid();
+                Logger.LogTrace("[BASE-{appBase}] {this} visibility changed, now: {visi}, cached data exists", appData, this, IsVisible);
+
+                _ = Task.Run(() =>
+                {
+                    ApplyCharacterData(appData, _cachedData!, forceApplyCustomization: true);
+                });
+            }
+            else
+            {
+                Logger.LogTrace("{this} visibility changed, now: {visi}, no cached data exists", this, IsVisible);
+            }
+        }
+        else if (IsVisible && !nowVisible)
+        {
+            IsVisible = false;
+            _charaHandler?.Invalidate();
+            _downloadCancellationTokenSource?.CancelDispose();
+            _downloadCancellationTokenSource = null;
+            Logger.LogTrace("{this} visibility changed, now: {visi}", this, IsVisible);
+        }
+    }
+
+    private void Initialize(string name)
+    {
+        PlayerName = name;
+        _charaHandler = _gameObjectHandlerFactory.Create(ObjectKind.Player, () => _dalamudUtil.GetPlayerCharacterFromCachedTableByIdent(Pair.Ident), isWatched: false).GetAwaiter().GetResult();
+
+        Mediator.Subscribe<HonorificReadyMessage>(this, msg =>
+        {
+            if (string.IsNullOrEmpty(_cachedData?.HonorificData)) return;
+            Logger.LogTrace("Reapplying Honorific data for {this}", this);
+            _ = Task.Run(async () => await _ipcManager.Honorific.SetTitleAsync(PlayerCharacter, _cachedData.HonorificData).ConfigureAwait(false), CancellationToken.None);
+        });
+
+        Mediator.Subscribe<PetNamesReadyMessage>(this, msg =>
+        {
+            if (string.IsNullOrEmpty(_cachedData?.PetNamesData)) return;
+            Logger.LogTrace("Reapplying Pet Names data for {this}", this);
+            _ = Task.Run(async () => await _ipcManager.PetNames.SetPlayerData(PlayerCharacter, _cachedData.PetNamesData).ConfigureAwait(false), CancellationToken.None);
+        });
+    }
+
+    private async Task RevertCustomizationDataAsync(ObjectKind objectKind, string name, Guid applicationId, CancellationToken cancelToken)
+    {
+        nint address = _dalamudUtil.GetPlayerCharacterFromCachedTableByIdent(Pair.Ident);
+        if (address == nint.Zero) return;
+
+        Logger.LogDebug("[{applicationId}] Reverting all Customization for {alias}/{name} {objectKind}", applicationId, Pair.UserData.AliasOrUID, name, objectKind);
+
+        if (_customizeIds.TryGetValue(objectKind, out var customizeId))
+        {
+            _customizeIds.Remove(objectKind);
+        }
+
+        if (objectKind == ObjectKind.Player)
+        {
+            using GameObjectHandler tempHandler = await _gameObjectHandlerFactory.Create(ObjectKind.Player, () => address, isWatched: false).ConfigureAwait(false);
+            tempHandler.CompareNameAndThrow(name);
+            Logger.LogDebug("[{applicationId}] Restoring Customization and Equipment for {alias}/{name}", applicationId, Pair.UserData.AliasOrUID, name);
+            await _ipcManager.Glamourer.RevertAsync(Logger, tempHandler, applicationId, cancelToken).ConfigureAwait(false);
+            tempHandler.CompareNameAndThrow(name);
+            Logger.LogDebug("[{applicationId}] Restoring Heels for {alias}/{name}", applicationId, Pair.UserData.AliasOrUID, name);
+            await _ipcManager.Heels.RestoreOffsetForPlayerAsync(address).ConfigureAwait(false);
+            tempHandler.CompareNameAndThrow(name);
+            Logger.LogDebug("[{applicationId}] Restoring C+ for {alias}/{name}", applicationId, Pair.UserData.AliasOrUID, name);
+            await _ipcManager.CustomizePlus.RevertByIdAsync(customizeId).ConfigureAwait(false);
+            tempHandler.CompareNameAndThrow(name);
+            Logger.LogDebug("[{applicationId}] Restoring Honorific for {alias}/{name}", applicationId, Pair.UserData.AliasOrUID, name);
+            await _ipcManager.Honorific.ClearTitleAsync(address).ConfigureAwait(false);
+            Logger.LogDebug("[{applicationId}] Restoring Pet Nicknames for {alias}/{name}", applicationId, Pair.UserData.AliasOrUID, name);
+            await _ipcManager.PetNames.ClearPlayerData(address).ConfigureAwait(false);
+            Logger.LogDebug("[{applicationId}] Restoring Moodles for {alias}/{name}", applicationId, Pair.UserData.AliasOrUID, name);
+            await _ipcManager.Moodles.RevertStatusAsync(address).ConfigureAwait(false);
+        }
+        else if (objectKind == ObjectKind.MinionOrMount)
+        {
+            var minionOrMount = await _dalamudUtil.GetMinionOrMountAsync(address).ConfigureAwait(false);
+            if (minionOrMount != nint.Zero)
+            {
+                await _ipcManager.CustomizePlus.RevertByIdAsync(customizeId).ConfigureAwait(false);
+                using GameObjectHandler tempHandler = await _gameObjectHandlerFactory.Create(ObjectKind.MinionOrMount, () => minionOrMount, isWatched: false).ConfigureAwait(false);
+                await _ipcManager.Glamourer.RevertAsync(Logger, tempHandler, applicationId, cancelToken).ConfigureAwait(false);
+                await _ipcManager.Penumbra.RedrawAsync(Logger, tempHandler, applicationId, cancelToken).ConfigureAwait(false);
+            }
+        }
+        else if (objectKind == ObjectKind.Pet)
+        {
+            var pet = await _dalamudUtil.GetPetAsync(address).ConfigureAwait(false);
+            if (pet != nint.Zero)
+            {
+                await _ipcManager.CustomizePlus.RevertByIdAsync(customizeId).ConfigureAwait(false);
+                using GameObjectHandler tempHandler = await _gameObjectHandlerFactory.Create(ObjectKind.Pet, () => pet, isWatched: false).ConfigureAwait(false);
+                await _ipcManager.Glamourer.RevertAsync(Logger, tempHandler, applicationId, cancelToken).ConfigureAwait(false);
+                await _ipcManager.Penumbra.RedrawAsync(Logger, tempHandler, applicationId, cancelToken).ConfigureAwait(false);
+            }
+        }
+        else if (objectKind == ObjectKind.Companion)
+        {
+            var companion = await _dalamudUtil.GetCompanionAsync(address).ConfigureAwait(false);
+            if (companion != nint.Zero)
+            {
+                await _ipcManager.CustomizePlus.RevertByIdAsync(customizeId).ConfigureAwait(false);
+                using GameObjectHandler tempHandler = await _gameObjectHandlerFactory.Create(ObjectKind.Pet, () => companion, isWatched: false).ConfigureAwait(false);
+                await _ipcManager.Glamourer.RevertAsync(Logger, tempHandler, applicationId, cancelToken).ConfigureAwait(false);
+                await _ipcManager.Penumbra.RedrawAsync(Logger, tempHandler, applicationId, cancelToken).ConfigureAwait(false);
+            }
+        }
+    }
+
+    private List<FileReplacementData> TryCalculateModdedDictionary(Guid applicationBase, CharacterData charaData, out Dictionary<(string GamePath, string? Hash), string> moddedDictionary, CancellationToken token)
+    {
+        Stopwatch st = Stopwatch.StartNew();
+        ConcurrentBag<FileReplacementData> missingFiles = [];
+        moddedDictionary = [];
+        ConcurrentDictionary<(string GamePath, string? Hash), string> outputDict = new();
+        bool hasMigrationChanges = false;
+
+        try
+        {
+            var replacementList = charaData.FileReplacements.SelectMany(k => k.Value.Where(v => string.IsNullOrEmpty(v.FileSwapPath))).ToList();
+            Parallel.ForEach(replacementList, new ParallelOptions()
+            {
+                CancellationToken = token,
+                MaxDegreeOfParallelism = 4
+            },
+            (item) =>
+            {
+                token.ThrowIfCancellationRequested();
+                var fileCache = _fileDbManager.GetFileCacheByHash(item.Hash, preferSubst: true);
+                if (fileCache != null)
+                {
+                    if (string.IsNullOrEmpty(new FileInfo(fileCache.ResolvedFilepath).Extension))
+                    {
+                        hasMigrationChanges = true;
+                        fileCache = _fileDbManager.MigrateFileHashToExtension(fileCache, item.GamePaths[0].Split(".")[^1]);
+                    }
+
+                    foreach (var gamePath in item.GamePaths)
+                    {
+                        outputDict[(gamePath, item.Hash)] = fileCache.ResolvedFilepath;
+                    }
+                }
+                else
+                {
+                    Logger.LogTrace("Missing file: {hash}", item.Hash);
+                    missingFiles.Add(item);
+                }
+            });
+
+            moddedDictionary = outputDict.ToDictionary(k => k.Key, k => k.Value);
+
+            foreach (var item in charaData.FileReplacements.SelectMany(k => k.Value.Where(v => !string.IsNullOrEmpty(v.FileSwapPath))).ToList())
+            {
+                foreach (var gamePath in item.GamePaths)
+                {
+                    Logger.LogTrace("[BASE-{appBase}] Adding file swap for {path}: {fileSwap}", applicationBase, gamePath, item.FileSwapPath);
+                    moddedDictionary[(gamePath, null)] = item.FileSwapPath;
+                }
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError(ex, "[BASE-{appBase}] Something went wrong during calculation replacements", applicationBase);
+        }
+        if (hasMigrationChanges) _fileDbManager.WriteOutFullCsv();
+        st.Stop();
+        Logger.LogDebug("[BASE-{appBase}] ModdedPaths calculated in {time}ms, missing files: {count}, total files: {total}", applicationBase, st.ElapsedMilliseconds, missingFiles.Count, moddedDictionary.Keys.Count);
+        return [.. missingFiles];
+    }
+}

MareSynchronos/PlayerData/Pairs/OnlinePlayerManager.cs

@@ -0,0 +1,75 @@
+using MareSynchronos.API.Data;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Utils;
+using MareSynchronos.WebAPI;
+using MareSynchronos.WebAPI.Files;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.PlayerData.Pairs;
+
+public class OnlinePlayerManager : DisposableMediatorSubscriberBase
+{
+    private readonly ApiController _apiController;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly FileUploadManager _fileTransferManager;
+    private readonly HashSet<PairHandler> _newVisiblePlayers = [];
+    private readonly PairManager _pairManager;
+    private CharacterData? _lastSentData;
+
+    public OnlinePlayerManager(ILogger<OnlinePlayerManager> logger, ApiController apiController, DalamudUtilService dalamudUtil,
+        PairManager pairManager, MareMediator mediator, FileUploadManager fileTransferManager) : base(logger, mediator)
+    {
+        _apiController = apiController;
+        _dalamudUtil = dalamudUtil;
+        _pairManager = pairManager;
+        _fileTransferManager = fileTransferManager;
+        Mediator.Subscribe<PlayerChangedMessage>(this, (_) => PlayerManagerOnPlayerHasChanged());
+        Mediator.Subscribe<DelayedFrameworkUpdateMessage>(this, (_) => FrameworkOnUpdate());
+        Mediator.Subscribe<CharacterDataCreatedMessage>(this, (msg) =>
+        {
+            var newData = msg.CharacterData;
+            if (_lastSentData == null || (!string.Equals(newData.DataHash.Value, _lastSentData.DataHash.Value, StringComparison.Ordinal)))
+            {
+                Logger.LogDebug("Pushing data for visible players");
+                _lastSentData = newData;
+                PushCharacterData(_pairManager.GetVisibleUsers());
+            }
+            else
+            {
+                Logger.LogDebug("Not sending data for {hash}", newData.DataHash.Value);
+            }
+        });
+        Mediator.Subscribe<PairHandlerVisibleMessage>(this, (msg) => _newVisiblePlayers.Add(msg.Player));
+        Mediator.Subscribe<ConnectedMessage>(this, (_) => PushCharacterData(_pairManager.GetVisibleUsers()));
+    }
+
+    private void FrameworkOnUpdate()
+    {
+        if (!_dalamudUtil.GetIsPlayerPresent() || !_apiController.IsConnected) return;
+
+        if (!_newVisiblePlayers.Any()) return;
+        var newVisiblePlayers = _newVisiblePlayers.ToList();
+        _newVisiblePlayers.Clear();
+        Logger.LogTrace("Has new visible players, pushing character data");
+        PushCharacterData(newVisiblePlayers.Select(c => c.Pair.UserData).ToList());
+    }
+
+    private void PlayerManagerOnPlayerHasChanged()
+    {
+        PushCharacterData(_pairManager.GetVisibleUsers());
+    }
+
+    private void PushCharacterData(List<UserData> visiblePlayers)
+    {
+        if (visiblePlayers.Any() && _lastSentData != null)
+        {
+            _ = Task.Run(async () =>
+            {
+                var dataToSend = await _fileTransferManager.UploadFiles(_lastSentData.DeepClone(), visiblePlayers).ConfigureAwait(false);
+                await _apiController.PushCharacterData(dataToSend, visiblePlayers).ConfigureAwait(false);
+            });
+        }
+    }
+}

MareSynchronos/PlayerData/Pairs/OptionalPluginWarning.cs

@@ -0,0 +1,10 @@
+namespace MareSynchronos.PlayerData.Pairs;
+
+public record OptionalPluginWarning
+{
+    public bool ShownHeelsWarning { get; set; } = false;
+    public bool ShownCustomizePlusWarning { get; set; } = false;
+    public bool ShownHonorificWarning { get; set; } = false;
+    public bool ShowPetNicknamesWarning { get; set; } = false;
+    public bool ShownMoodlesWarning { get; set; } = false;
+}

MareSynchronos/PlayerData/Pairs/Pair.cs

@@ -0,0 +1,376 @@
+using Dalamud.Game.Gui.ContextMenu;
+using Dalamud.Game.Text.SeStringHandling;
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Data.Comparer;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.API.Dto.Group;
+using MareSynchronos.API.Dto.User;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.PlayerData.Factories;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using MareSynchronos.Utils;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+
+namespace MareSynchronos.PlayerData.Pairs;
+
+public class Pair : DisposableMediatorSubscriberBase
+{
+    private readonly PairHandlerFactory _cachedPlayerFactory;
+    private readonly SemaphoreSlim _creationSemaphore = new(1);
+    private readonly ILogger<Pair> _logger;
+    private readonly MareConfigService _mareConfig;
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+    private CancellationTokenSource _applicationCts = new();
+    private OnlineUserIdentDto? _onlineUserIdentDto = null;
+
+    public Pair(ILogger<Pair> logger, UserData userData, PairHandlerFactory cachedPlayerFactory,
+        MareMediator mediator, MareConfigService mareConfig, ServerConfigurationManager serverConfigurationManager)
+        : base(logger, mediator)
+    {
+        _logger = logger;
+        _cachedPlayerFactory = cachedPlayerFactory;
+        _mareConfig = mareConfig;
+        _serverConfigurationManager = serverConfigurationManager;
+
+        UserData = userData;
+
+        Mediator.SubscribeKeyed<HoldPairApplicationMessage>(this, UserData.UID, (msg) => HoldApplication(msg.Source));
+        Mediator.SubscribeKeyed<UnholdPairApplicationMessage>(this, UserData.UID, (msg) => UnholdApplication(msg.Source));
+    }
+
+    public Dictionary<GroupFullInfoDto, GroupPairFullInfoDto> GroupPair { get; set; } = new(GroupDtoComparer.Instance);
+    public bool HasCachedPlayer => CachedPlayer != null && !string.IsNullOrEmpty(CachedPlayer.PlayerName) && _onlineUserIdentDto != null;
+    public bool IsOnline => CachedPlayer != null;
+
+    public bool IsPaused => UserPair != null && UserPair.OtherPermissions.IsPaired() ? UserPair.OtherPermissions.IsPaused() || UserPair.OwnPermissions.IsPaused()
+            : GroupPair.All(p => p.Key.GroupUserPermissions.IsPaused() || p.Value.GroupUserPermissions.IsPaused());
+
+    // Download locks apply earlier in the process than Application locks
+    private ConcurrentDictionary<string, int> HoldDownloadLocks { get; set; } = new(StringComparer.Ordinal);
+    private ConcurrentDictionary<string, int> HoldApplicationLocks { get; set; } = new(StringComparer.Ordinal);
+
+    public bool IsDownloadBlocked => HoldDownloadLocks.Any(f => f.Value > 0);
+    public bool IsApplicationBlocked => HoldApplicationLocks.Any(f => f.Value > 0) || IsDownloadBlocked;
+
+    public IEnumerable<string> HoldDownloadReasons => HoldDownloadLocks.Keys;
+    public IEnumerable<string> HoldApplicationReasons => Enumerable.Concat(HoldDownloadLocks.Keys, HoldApplicationLocks.Keys);
+
+    public bool IsVisible => CachedPlayer?.IsVisible ?? false;
+    public CharacterData? LastReceivedCharacterData { get; set; }
+    public string? PlayerName => GetPlayerName();
+    public uint PlayerCharacterId => GetPlayerCharacterId();
+    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 PairAnalyzer? PairAnalyzer => CachedPlayer?.PairAnalyzer;
+
+    public UserData UserData { get; init; }
+
+    public UserPairDto? 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;
+
+        void Add(string name, Action<IMenuItemClickedArgs>? action)
+        {
+            args.AddMenuItem(new MenuItem()
+            {
+                Name = name,
+                OnClicked = action,
+                PrefixColor = 559,
+                PrefixChar = 'L'
+            });
+        }
+
+        bool isBlocked = IsApplicationBlocked;
+        bool isBlacklisted = _serverConfigurationManager.IsUidBlacklisted(UserData.UID);
+        bool isWhitelisted = _serverConfigurationManager.IsUidWhitelisted(UserData.UID);
+
+        Add("Open Profile", _ => Mediator.Publish(new ProfileOpenStandaloneMessage(this)));
+
+        if (!isBlocked && !isBlacklisted)
+            Add("Always Block Modded Appearance", _ => {
+                    _serverConfigurationManager.AddBlacklistUid(UserData.UID);
+                    HoldApplication("Blacklist", maxValue: 1);
+                    ApplyLastReceivedData(forced: true);
+                });
+        else if (isBlocked && !isWhitelisted)
+            Add("Always Allow Modded Appearance", _ => {
+                    _serverConfigurationManager.AddWhitelistUid(UserData.UID);
+                    UnholdApplication("Blacklist", skipApplication: true);
+                    ApplyLastReceivedData(forced: true);
+                });
+
+        if (isWhitelisted)
+            Add("Remove from Whitelist", _ => {
+                _serverConfigurationManager.RemoveWhitelistUid(UserData.UID);
+                ApplyLastReceivedData(forced: true);
+            });
+        else if (isBlacklisted)
+            Add("Remove from Blacklist", _ => {
+                _serverConfigurationManager.RemoveBlacklistUid(UserData.UID);
+                UnholdApplication("Blacklist", skipApplication: true);
+                ApplyLastReceivedData(forced: true);
+            });
+
+        Add("Reapply last data", _ => ApplyLastReceivedData(forced: true));
+
+        if (UserPair != null)
+        {
+            Add("Change Permissions", _ => Mediator.Publish(new OpenPermissionWindow(this)));
+            Add("Cycle pause state", _ => Mediator.Publish(new CyclePauseMessage(UserData)));
+        }
+    }
+
+    public void ApplyData(OnlineUserCharaDataDto data)
+    {
+        _applicationCts = _applicationCts.CancelRecreate();
+        LastReceivedCharacterData = data.CharaData;
+
+        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();
+    }
+
+    public void ApplyLastReceivedData(bool forced = false)
+    {
+        if (CachedPlayer == null) return;
+        if (LastReceivedCharacterData == null) return;
+        if (IsDownloadBlocked) return;
+
+        if (_serverConfigurationManager.IsUidBlacklisted(UserData.UID))
+            HoldApplication("Blacklist", maxValue: 1);
+
+        if (NoSnapService.AnyLoaded)
+            HoldApplication("NoSnap", maxValue: 1);
+        else
+            UnholdApplication("NoSnap", skipApplication: true);
+
+        CachedPlayer.ApplyCharacterData(Guid.NewGuid(), RemoveNotSyncedFiles(LastReceivedCharacterData.DeepClone())!, forced);
+    }
+
+    public void CreateCachedPlayer(OnlineUserIdentDto? dto = null)
+    {
+        try
+        {
+            _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);
+        }
+        finally
+        {
+            _creationSemaphore.Release();
+        }
+    }
+
+    public string? GetNote()
+    {
+        return _serverConfigurationManager.GetNoteForUid(UserData.UID);
+    }
+
+    public string? GetPlayerName()
+    {
+        if (CachedPlayer != null && CachedPlayer.PlayerName != null)
+            return CachedPlayer.PlayerName;
+        else
+            return _serverConfigurationManager.GetNameForUid(UserData.UID);
+    }
+
+    public uint GetPlayerCharacterId()
+    {
+        if (CachedPlayer != null)
+            return CachedPlayer.PlayerCharacterId;
+        return uint.MaxValue;
+    }
+
+    public string? GetNoteOrName()
+    {
+        string? note = GetNote();
+        if (_mareConfig.Current.ShowCharacterNames || IsVisible)
+            return note ?? GetPlayerName();
+        else
+            return note;
+    }
+
+    public string GetPairSortKey()
+    {
+        string? noteOrName = GetNoteOrName();
+
+        if (noteOrName != null)
+            return $"0{noteOrName}";
+        else
+            return $"9{UserData.AliasOrUID}";
+    }
+
+    public string GetPlayerNameHash()
+    {
+        return CachedPlayer?.PlayerNameHash ?? string.Empty;
+    }
+
+    public bool HasAnyConnection()
+    {
+        return UserPair != null || GroupPair.Any();
+    }
+
+    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();
+        }
+    }
+
+    public void SetNote(string note)
+    {
+        _serverConfigurationManager.SetNoteForUid(UserData.UID, note);
+    }
+
+    internal void SetIsUploading()
+    {
+        CachedPlayer?.SetUploading();
+    }
+
+    public void HoldApplication(string source, int maxValue = int.MaxValue)
+    {
+        _logger.LogDebug($"Holding {UserData.UID} for reason: {source}");
+        bool wasHeld = IsApplicationBlocked;
+        HoldApplicationLocks.AddOrUpdate(source, 1, (k, v) => Math.Min(maxValue, v + 1));
+        if (!wasHeld)
+            CachedPlayer?.UndoApplication();
+    }
+
+    public void UnholdApplication(string source, bool skipApplication = false)
+    {
+        _logger.LogDebug($"Un-holding {UserData.UID} for reason: {source}");
+        bool wasHeld = IsApplicationBlocked;
+        HoldApplicationLocks.AddOrUpdate(source, 0, (k, v) => Math.Max(0, v - 1));
+        HoldApplicationLocks.TryRemove(new(source, 0));
+        if (!skipApplication && wasHeld && !IsApplicationBlocked)
+            ApplyLastReceivedData(forced: true);
+    }
+
+    public void HoldDownloads(string source, int maxValue = int.MaxValue)
+    {
+        _logger.LogDebug($"Holding {UserData.UID} for reason: {source}");
+        bool wasHeld = IsApplicationBlocked;
+        HoldDownloadLocks.AddOrUpdate(source, 1, (k, v) => Math.Min(maxValue, v + 1));
+        if (!wasHeld)
+            CachedPlayer?.UndoApplication();
+    }
+
+    public void UnholdDownloads(string source, bool skipApplication = false)
+    {
+        _logger.LogDebug($"Un-holding {UserData.UID} for reason: {source}");
+        bool wasHeld = IsApplicationBlocked;
+        HoldDownloadLocks.AddOrUpdate(source, 0, (k, v) => Math.Max(0, v - 1));
+        HoldDownloadLocks.TryRemove(new(source, 0));
+        if (!skipApplication && wasHeld && !IsApplicationBlocked)
+            ApplyLastReceivedData(forced: true);
+    }
+
+    private CharacterData? RemoveNotSyncedFiles(CharacterData? data)
+    {
+        _logger.LogTrace("Removing not synced files");
+        if (data == null)
+        {
+            _logger.LogTrace("Nothing to remove");
+            return data;
+        }
+
+        var ActiveGroupPairs = GroupPair.Where(p => !p.Value.GroupUserPermissions.IsPaused() && !p.Key.GroupUserPermissions.IsPaused()).ToList();
+
+        bool disableIndividualAnimations = UserPair != null && (UserPair.OtherPermissions.IsDisableAnimations() || UserPair.OwnPermissions.IsDisableAnimations());
+        bool disableIndividualVFX = UserPair != null && (UserPair.OtherPermissions.IsDisableVFX() || UserPair.OwnPermissions.IsDisableVFX());
+        bool disableGroupAnimations = ActiveGroupPairs.All(pair => pair.Value.GroupUserPermissions.IsDisableAnimations() || pair.Key.GroupPermissions.IsDisableAnimations() || pair.Key.GroupUserPermissions.IsDisableAnimations());
+
+        bool disableAnimations = (UserPair != null && disableIndividualAnimations) || (UserPair == null && disableGroupAnimations);
+
+        bool disableIndividualSounds = UserPair != null && (UserPair.OtherPermissions.IsDisableSounds() || UserPair.OwnPermissions.IsDisableSounds());
+        bool disableGroupSounds = ActiveGroupPairs.All(pair => pair.Value.GroupUserPermissions.IsDisableSounds() || pair.Key.GroupPermissions.IsDisableSounds() || pair.Key.GroupUserPermissions.IsDisableSounds());
+        bool disableGroupVFX = ActiveGroupPairs.All(pair => pair.Value.GroupUserPermissions.IsDisableVFX() || pair.Key.GroupPermissions.IsDisableVFX() || pair.Key.GroupUserPermissions.IsDisableVFX());
+
+        bool disableSounds = (UserPair != null && disableIndividualSounds) || (UserPair == null && disableGroupSounds);
+        bool disableVFX = (UserPair != null && disableIndividualVFX) || (UserPair == null && disableGroupVFX);
+
+        _logger.LogTrace("Disable: Sounds: {disableSounds}, Anims: {disableAnimations}, VFX: {disableVFX}",
+            disableSounds, disableAnimations, disableVFX);
+
+        if (disableAnimations || disableSounds || disableVFX)
+        {
+            _logger.LogTrace("Data cleaned up: Animations disabled: {disableAnimations}, Sounds disabled: {disableSounds}, VFX disabled: {disableVFX}",
+                disableAnimations, disableSounds, disableVFX);
+            foreach (var objectKind in data.FileReplacements.Select(k => k.Key))
+            {
+                if (disableSounds)
+                    data.FileReplacements[objectKind] = data.FileReplacements[objectKind]
+                        .Where(f => !f.GamePaths.Any(p => p.EndsWith("scd", StringComparison.OrdinalIgnoreCase)))
+                        .ToList();
+                if (disableAnimations)
+                    data.FileReplacements[objectKind] = data.FileReplacements[objectKind]
+                        .Where(f => !f.GamePaths.Any(p => p.EndsWith("tmb", StringComparison.OrdinalIgnoreCase) || p.EndsWith("pap", StringComparison.OrdinalIgnoreCase)))
+                        .ToList();
+                if (disableVFX)
+                    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;
+    }
+}

MareSynchronos/PlayerData/Pairs/PairManager.cs

@@ -0,0 +1,403 @@
+using Dalamud.Plugin.Services;
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Data.Comparer;
+using MareSynchronos.API.Data.Extensions;
+using MareSynchronos.API.Dto.Group;
+using MareSynchronos.API.Dto.User;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.MareConfiguration.Models;
+using MareSynchronos.PlayerData.Factories;
+using MareSynchronos.Services.Events;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+
+namespace MareSynchronos.PlayerData.Pairs;
+
+public sealed class PairManager : DisposableMediatorSubscriberBase
+{
+    private readonly ConcurrentDictionary<UserData, Pair> _allClientPairs = new(UserDataComparer.Instance);
+    private readonly ConcurrentDictionary<GroupData, GroupFullInfoDto> _allGroups = new(GroupDataComparer.Instance);
+    private readonly MareConfigService _configurationService;
+    private readonly IContextMenu _dalamudContextMenu;
+    private readonly PairFactory _pairFactory;
+    private Lazy<List<Pair>> _directPairsInternal;
+    private Lazy<Dictionary<GroupFullInfoDto, List<Pair>>> _groupPairsInternal;
+
+    public PairManager(ILogger<PairManager> logger, PairFactory pairFactory,
+                MareConfigService configurationService, MareMediator mediator,
+                IContextMenu dalamudContextMenu) : base(logger, mediator)
+    {
+        _pairFactory = pairFactory;
+        _configurationService = configurationService;
+        _dalamudContextMenu = dalamudContextMenu;
+        Mediator.Subscribe<DisconnectedMessage>(this, (_) => ClearPairs());
+        Mediator.Subscribe<CutsceneEndMessage>(this, (_) => ReapplyPairData());
+        _directPairsInternal = DirectPairsLazy();
+        _groupPairsInternal = GroupPairsLazy();
+
+        _dalamudContextMenu.OnMenuOpened += DalamudContextMenuOnOnOpenGameObjectContextMenu;
+    }
+
+    public List<Pair> DirectPairs => _directPairsInternal.Value;
+
+    public Dictionary<GroupFullInfoDto, List<Pair>> GroupPairs => _groupPairsInternal.Value;
+    public Dictionary<GroupData, GroupFullInfoDto> Groups => _allGroups.ToDictionary(k => k.Key, k => k.Value);
+    public Pair? LastAddedUser { get; internal set; }
+
+    public void AddGroup(GroupFullInfoDto dto)
+    {
+        _allGroups[dto.Group] = dto;
+        RecreateLazy();
+    }
+
+    public void AddGroupPair(GroupPairFullInfoDto dto)
+    {
+        if (!_allClientPairs.ContainsKey(dto.User))
+            _allClientPairs[dto.User] = _pairFactory.Create(dto.User);
+
+        var group = _allGroups[dto.Group];
+        _allClientPairs[dto.User].GroupPair[group] = dto;
+        RecreateLazy();
+    }
+
+    public Pair? GetPairByUID(string uid)
+    {
+        var existingPair = _allClientPairs.FirstOrDefault(f => uid.Equals(f.Key.UID, StringComparison.Ordinal));
+        if (!Equals(existingPair, default(KeyValuePair<UserData, Pair>)))
+        {
+            return existingPair.Value;
+        }
+
+        return null;
+    }
+
+    public void AddUserPair(UserPairDto dto, bool addToLastAddedUser = true)
+    {
+        if (!_allClientPairs.ContainsKey(dto.User))
+        {
+            _allClientPairs[dto.User] = _pairFactory.Create(dto.User);
+        }
+        else
+        {
+            addToLastAddedUser = false;
+        }
+
+        _allClientPairs[dto.User].UserPair = dto;
+        if (addToLastAddedUser)
+            LastAddedUser = _allClientPairs[dto.User];
+        _allClientPairs[dto.User].ApplyLastReceivedData();
+        RecreateLazy();
+    }
+
+    public void ClearPairs()
+    {
+        Logger.LogDebug("Clearing all Pairs");
+        DisposePairs();
+        _allClientPairs.Clear();
+        _allGroups.Clear();
+        RecreateLazy();
+    }
+
+    public List<Pair> GetOnlineUserPairs() => _allClientPairs.Where(p => !string.IsNullOrEmpty(p.Value.GetPlayerNameHash())).Select(p => p.Value).ToList();
+
+    public int GetVisibleUserCount() => _allClientPairs.Count(p => p.Value.IsVisible);
+
+    public List<UserData> GetVisibleUsers() => _allClientPairs.Where(p => p.Value.IsVisible).Select(p => p.Key).ToList();
+
+    public void MarkPairOffline(UserData user)
+    {
+        if (_allClientPairs.TryGetValue(user, out var pair))
+        {
+            Mediator.Publish(new ClearProfileDataMessage(pair.UserData));
+            pair.MarkOffline();
+        }
+
+        RecreateLazy();
+    }
+
+    public void MarkPairOnline(OnlineUserIdentDto dto, bool sendNotif = true)
+    {
+        if (!_allClientPairs.ContainsKey(dto.User)) throw new InvalidOperationException("No user found for " + dto);
+
+        Mediator.Publish(new ClearProfileDataMessage(dto.User));
+
+        var pair = _allClientPairs[dto.User];
+        if (pair.HasCachedPlayer)
+        {
+            RecreateLazy();
+            return;
+        }
+
+        if (sendNotif && _configurationService.Current.ShowOnlineNotifications
+            && (_configurationService.Current.ShowOnlineNotificationsOnlyForIndividualPairs && pair.UserPair != null
+            || !_configurationService.Current.ShowOnlineNotificationsOnlyForIndividualPairs)
+            && (_configurationService.Current.ShowOnlineNotificationsOnlyForNamedPairs && !string.IsNullOrEmpty(pair.GetNote())
+            || !_configurationService.Current.ShowOnlineNotificationsOnlyForNamedPairs))
+        {
+            string? note = pair.GetNoteOrName();
+            var msg = !string.IsNullOrEmpty(note)
+                ? $"{note} ({pair.UserData.AliasOrUID}) is now online"
+                : $"{pair.UserData.AliasOrUID} is now online";
+            Mediator.Publish(new NotificationMessage("User online", msg, NotificationType.Info, TimeSpan.FromSeconds(5)));
+        }
+
+        pair.CreateCachedPlayer(dto);
+
+        RecreateLazy();
+    }
+
+    public void ReceiveCharaData(OnlineUserCharaDataDto dto)
+    {
+        if (!_allClientPairs.TryGetValue(dto.User, out var pair)) throw new InvalidOperationException("No user found for " + dto.User);
+
+        Mediator.Publish(new EventMessage(new Event(pair.UserData, nameof(PairManager), EventSeverity.Informational, "Received Character Data")));
+        _allClientPairs[dto.User].ApplyData(dto);
+    }
+
+    public void RemoveGroup(GroupData data)
+    {
+        _allGroups.TryRemove(data, out _);
+
+        foreach (var item in _allClientPairs.ToList())
+        {
+            foreach (var grpPair in item.Value.GroupPair.Select(k => k.Key).Where(grpPair => GroupDataComparer.Instance.Equals(grpPair.Group, data)).ToList())
+            {
+                _allClientPairs[item.Key].GroupPair.Remove(grpPair);
+            }
+
+            if (!_allClientPairs[item.Key].HasAnyConnection() && _allClientPairs.TryRemove(item.Key, out var pair))
+            {
+                pair.MarkOffline();
+            }
+        }
+
+        RecreateLazy();
+    }
+
+    public void RemoveGroupPair(GroupPairDto dto)
+    {
+        if (_allClientPairs.TryGetValue(dto.User, out var pair))
+        {
+            var group = _allGroups[dto.Group];
+            pair.GroupPair.Remove(group);
+
+            if (!pair.HasAnyConnection())
+            {
+                pair.MarkOffline();
+                _allClientPairs.TryRemove(dto.User, out _);
+            }
+        }
+
+        RecreateLazy();
+    }
+
+    public void RemoveUserPair(UserDto dto)
+    {
+        if (_allClientPairs.TryGetValue(dto.User, out var pair))
+        {
+            pair.UserPair = null;
+
+            if (!pair.HasAnyConnection())
+            {
+                pair.MarkOffline();
+                _allClientPairs.TryRemove(dto.User, out _);
+            }
+        }
+
+        RecreateLazy();
+    }
+
+    public void SetGroupInfo(GroupInfoDto dto)
+    {
+        _allGroups[dto.Group].Group = dto.Group;
+        _allGroups[dto.Group].Owner = dto.Owner;
+        _allGroups[dto.Group].GroupPermissions = dto.GroupPermissions;
+
+        RecreateLazy();
+    }
+
+    public void UpdatePairPermissions(UserPermissionsDto dto)
+    {
+        if (!_allClientPairs.TryGetValue(dto.User, out var pair))
+        {
+            throw new InvalidOperationException("No such pair for " + dto);
+        }
+
+        if (pair.UserPair == null) throw new InvalidOperationException("No direct pair for " + dto);
+
+        if (pair.UserPair.OtherPermissions.IsPaused() != dto.Permissions.IsPaused()
+            || pair.UserPair.OtherPermissions.IsPaired() != dto.Permissions.IsPaired())
+        {
+            Mediator.Publish(new ClearProfileDataMessage(dto.User));
+        }
+
+        pair.UserPair.OtherPermissions = dto.Permissions;
+
+        Logger.LogTrace("Paused: {paused}, Anims: {anims}, Sounds: {sounds}, VFX: {vfx}",
+            pair.UserPair.OtherPermissions.IsPaused(),
+            pair.UserPair.OtherPermissions.IsDisableAnimations(),
+            pair.UserPair.OtherPermissions.IsDisableSounds(),
+            pair.UserPair.OtherPermissions.IsDisableVFX());
+
+        if (!pair.IsPaused)
+            pair.ApplyLastReceivedData();
+
+        RecreateLazy();
+    }
+
+    public void UpdateSelfPairPermissions(UserPermissionsDto dto)
+    {
+        if (!_allClientPairs.TryGetValue(dto.User, out var pair))
+        {
+            throw new InvalidOperationException("No such pair for " + dto);
+        }
+
+        if (pair.UserPair == null) throw new InvalidOperationException("No direct pair for " + dto);
+
+        if (pair.UserPair.OwnPermissions.IsPaused() != dto.Permissions.IsPaused()
+            || pair.UserPair.OwnPermissions.IsPaired() != dto.Permissions.IsPaired())
+        {
+            Mediator.Publish(new ClearProfileDataMessage(dto.User));
+        }
+
+        pair.UserPair.OwnPermissions = dto.Permissions;
+
+        Logger.LogTrace("Paused: {paused}, Anims: {anims}, Sounds: {sounds}, VFX: {vfx}",
+            pair.UserPair.OwnPermissions.IsPaused(),
+            pair.UserPair.OwnPermissions.IsDisableAnimations(),
+            pair.UserPair.OwnPermissions.IsDisableSounds(),
+            pair.UserPair.OwnPermissions.IsDisableVFX());
+
+        if (!pair.IsPaused)
+            pair.ApplyLastReceivedData();
+
+        RecreateLazy();
+    }
+
+    internal void ReceiveUploadStatus(UserDto dto)
+    {
+        if (_allClientPairs.TryGetValue(dto.User, out var existingPair) && existingPair.IsVisible)
+        {
+            existingPair.SetIsUploading();
+        }
+    }
+
+    internal void SetGroupPairStatusInfo(GroupPairUserInfoDto dto)
+    {
+        var group = _allGroups[dto.Group];
+        _allClientPairs[dto.User].GroupPair[group].GroupPairStatusInfo = dto.GroupUserInfo;
+        RecreateLazy();
+    }
+
+    internal void SetGroupPairUserPermissions(GroupPairUserPermissionDto dto)
+    {
+        var group = _allGroups[dto.Group];
+        var prevPermissions = _allClientPairs[dto.User].GroupPair[group].GroupUserPermissions;
+        _allClientPairs[dto.User].GroupPair[group].GroupUserPermissions = dto.GroupPairPermissions;
+        if (prevPermissions.IsDisableAnimations() != dto.GroupPairPermissions.IsDisableAnimations()
+            || prevPermissions.IsDisableSounds() != dto.GroupPairPermissions.IsDisableSounds()
+            || prevPermissions.IsDisableVFX() != dto.GroupPairPermissions.IsDisableVFX())
+        {
+            _allClientPairs[dto.User].ApplyLastReceivedData();
+        }
+        RecreateLazy();
+    }
+
+    internal void SetGroupPermissions(GroupPermissionDto dto)
+    {
+        var prevPermissions = _allGroups[dto.Group].GroupPermissions;
+        _allGroups[dto.Group].GroupPermissions = dto.Permissions;
+        if (prevPermissions.IsDisableAnimations() != dto.Permissions.IsDisableAnimations()
+            || prevPermissions.IsDisableSounds() != dto.Permissions.IsDisableSounds()
+            || prevPermissions.IsDisableVFX() != dto.Permissions.IsDisableVFX())
+        {
+            RecreateLazy();
+            var group = _allGroups[dto.Group];
+            GroupPairs[group].ForEach(p => p.ApplyLastReceivedData());
+        }
+        RecreateLazy();
+    }
+
+    internal void SetGroupStatusInfo(GroupPairUserInfoDto dto)
+    {
+        _allGroups[dto.Group].GroupUserInfo = dto.GroupUserInfo;
+        RecreateLazy();
+    }
+
+    internal void SetGroupUserPermissions(GroupPairUserPermissionDto dto)
+    {
+        var prevPermissions = _allGroups[dto.Group].GroupUserPermissions;
+        _allGroups[dto.Group].GroupUserPermissions = dto.GroupPairPermissions;
+        if (prevPermissions.IsDisableAnimations() != dto.GroupPairPermissions.IsDisableAnimations()
+            || prevPermissions.IsDisableSounds() != dto.GroupPairPermissions.IsDisableSounds()
+            || prevPermissions.IsDisableVFX() != dto.GroupPairPermissions.IsDisableVFX())
+        {
+            RecreateLazy();
+            var group = _allGroups[dto.Group];
+            GroupPairs[group].ForEach(p => p.ApplyLastReceivedData());
+        }
+        RecreateLazy();
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        _dalamudContextMenu.OnMenuOpened -= DalamudContextMenuOnOnOpenGameObjectContextMenu;
+
+        DisposePairs();
+    }
+
+    private void DalamudContextMenuOnOnOpenGameObjectContextMenu(Dalamud.Game.Gui.ContextMenu.IMenuOpenedArgs args)
+    {
+        if (args.MenuType == Dalamud.Game.Gui.ContextMenu.ContextMenuType.Inventory) return;
+        if (!_configurationService.Current.EnableRightClickMenus) return;
+
+        foreach (var pair in _allClientPairs.Where((p => p.Value.IsVisible)))
+        {
+            pair.Value.AddContextMenu(args);
+        }
+    }
+
+    private Lazy<List<Pair>> DirectPairsLazy() => new(() => _allClientPairs.Select(k => k.Value)
+        .Where(k => k.UserPair != null).ToList());
+
+    private void DisposePairs()
+    {
+        Logger.LogDebug("Disposing all Pairs");
+        Parallel.ForEach(_allClientPairs, item =>
+        {
+            item.Value.MarkOffline(wait: false);
+        });
+
+        RecreateLazy();
+    }
+
+    private Lazy<Dictionary<GroupFullInfoDto, List<Pair>>> GroupPairsLazy()
+    {
+        return new Lazy<Dictionary<GroupFullInfoDto, List<Pair>>>(() =>
+        {
+            Dictionary<GroupFullInfoDto, List<Pair>> outDict = new();
+            foreach (var group in _allGroups)
+            {
+                outDict[group.Value] = _allClientPairs.Select(p => p.Value).Where(p => p.GroupPair.Any(g => GroupDataComparer.Instance.Equals(group.Key, g.Key.Group))).ToList();
+            }
+            return outDict;
+        });
+    }
+
+    private void ReapplyPairData()
+    {
+        foreach (var pair in _allClientPairs.Select(k => k.Value))
+        {
+            pair.ApplyLastReceivedData(forced: true);
+        }
+    }
+
+    private void RecreateLazy()
+    {
+        _directPairsInternal = DirectPairsLazy();
+        _groupPairsInternal = GroupPairsLazy();
+    }
+}

MareSynchronos/PlayerData/Services/CacheCreationService.cs

@@ -0,0 +1,263 @@
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.PlayerData.Data;
+using MareSynchronos.PlayerData.Factories;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.PlayerData.Services;
+
+#pragma warning disable MA0040
+
+public sealed class CacheCreationService : DisposableMediatorSubscriberBase
+{
+    private readonly SemaphoreSlim _cacheCreateLock = new(1);
+    private readonly Dictionary<ObjectKind, GameObjectHandler> _cachesToCreate = [];
+    private readonly PlayerDataFactory _characterDataFactory;
+    private readonly CancellationTokenSource _cts = new();
+    private readonly CharacterData _playerData = new();
+    private readonly Dictionary<ObjectKind, GameObjectHandler> _playerRelatedObjects = [];
+    private Task? _cacheCreationTask;
+    private CancellationTokenSource _honorificCts = new();
+    private CancellationTokenSource _petNicknamesCts = new();
+    private CancellationTokenSource _moodlesCts = new();
+    private bool _isZoning = false;
+    private bool _haltCharaDataCreation;
+    private readonly Dictionary<ObjectKind, CancellationTokenSource> _glamourerCts = new();
+
+    public CacheCreationService(ILogger<CacheCreationService> logger, MareMediator mediator, GameObjectHandlerFactory gameObjectHandlerFactory,
+        PlayerDataFactory characterDataFactory, DalamudUtilService dalamudUtil) : base(logger, mediator)
+    {
+        _characterDataFactory = characterDataFactory;
+
+        Mediator.Subscribe<CreateCacheForObjectMessage>(this, (msg) =>
+        {
+            Logger.LogDebug("Received CreateCacheForObject for {handler}, updating", msg.ObjectToCreateFor);
+            _cacheCreateLock.Wait();
+            _cachesToCreate[msg.ObjectToCreateFor.ObjectKind] = msg.ObjectToCreateFor;
+            _cacheCreateLock.Release();
+        });
+
+        Mediator.Subscribe<ZoneSwitchStartMessage>(this, (msg) => _isZoning = true);
+        Mediator.Subscribe<ZoneSwitchEndMessage>(this, (msg) => _isZoning = false);
+
+        Mediator.Subscribe<HaltCharaDataCreation>(this, (msg) =>
+        {
+            _haltCharaDataCreation = !msg.Resume;
+        });
+
+        _playerRelatedObjects[ObjectKind.Player] = gameObjectHandlerFactory.Create(ObjectKind.Player, dalamudUtil.GetPlayerPointer, isWatched: true)
+            .GetAwaiter().GetResult();
+        _playerRelatedObjects[ObjectKind.MinionOrMount] = gameObjectHandlerFactory.Create(ObjectKind.MinionOrMount, () => dalamudUtil.GetMinionOrMount(), isWatched: true)
+            .GetAwaiter().GetResult();
+        _playerRelatedObjects[ObjectKind.Pet] = gameObjectHandlerFactory.Create(ObjectKind.Pet, () => dalamudUtil.GetPet(), isWatched: true)
+            .GetAwaiter().GetResult();
+        _playerRelatedObjects[ObjectKind.Companion] = gameObjectHandlerFactory.Create(ObjectKind.Companion, () => dalamudUtil.GetCompanion(), isWatched: true)
+            .GetAwaiter().GetResult();
+
+        Mediator.Subscribe<ClassJobChangedMessage>(this, (msg) =>
+        {
+            if (msg.GameObjectHandler != _playerRelatedObjects[ObjectKind.Player]) return;
+
+            Logger.LogTrace("Removing pet data for {obj}", msg.GameObjectHandler);
+            _playerData.FileReplacements.Remove(ObjectKind.Pet);
+            _playerData.GlamourerString.Remove(ObjectKind.Pet);
+            _playerData.CustomizePlusScale.Remove(ObjectKind.Pet);
+            Mediator.Publish(new CharacterDataCreatedMessage(_playerData.ToAPI()));
+        });
+
+        Mediator.Subscribe<ClearCacheForObjectMessage>(this, (msg) =>
+        {
+            // ignore pets
+            if (msg.ObjectToCreateFor == _playerRelatedObjects[ObjectKind.Pet]) return;
+            _ = Task.Run(() =>
+            {
+                Logger.LogTrace("Clearing cache for {obj}", msg.ObjectToCreateFor);
+                _playerData.FileReplacements.Remove(msg.ObjectToCreateFor.ObjectKind);
+                _playerData.GlamourerString.Remove(msg.ObjectToCreateFor.ObjectKind);
+                _playerData.CustomizePlusScale.Remove(msg.ObjectToCreateFor.ObjectKind);
+                Mediator.Publish(new CharacterDataCreatedMessage(_playerData.ToAPI()));
+            });
+        });
+
+        Mediator.Subscribe<CustomizePlusMessage>(this, (msg) =>
+        {
+            if (_isZoning) return;
+            _ = Task.Run(async () =>
+            {
+
+                foreach (var item in _playerRelatedObjects
+                    .Where(item => msg.Address == null
+                    || item.Value.Address == msg.Address).Select(k => k.Key))
+                {
+                    Logger.LogDebug("Received CustomizePlus change, updating {obj}", item);
+                    await AddPlayerCacheToCreate(item).ConfigureAwait(false);
+                }
+            });
+        });
+        Mediator.Subscribe<HeelsOffsetMessage>(this, (msg) =>
+        {
+            if (_isZoning) return;
+            Logger.LogDebug("Received Heels Offset change, updating player");
+            _ = AddPlayerCacheToCreate();
+        });
+        Mediator.Subscribe<GlamourerChangedMessage>(this, (msg) =>
+        {
+            if (_isZoning) return;
+            var changedType = _playerRelatedObjects.FirstOrDefault(f => f.Value.Address == msg.Address);
+            if (changedType.Key != default || changedType.Value != default)
+            {
+                GlamourerChanged(changedType.Key);
+            }
+        });
+        Mediator.Subscribe<HonorificMessage>(this, (msg) =>
+        {
+            if (_isZoning) return;
+            if (!string.Equals(msg.NewHonorificTitle, _playerData.HonorificData, StringComparison.Ordinal))
+            {
+                Logger.LogDebug("Received Honorific change, updating player");
+                HonorificChanged();
+            }
+        });
+        Mediator.Subscribe<PetNamesMessage>(this, (msg) =>
+        {
+            if (_isZoning) return;
+            if (!string.Equals(msg.PetNicknamesData, _playerData.PetNamesData, StringComparison.Ordinal))
+            {
+                Logger.LogDebug("Received Pet Nicknames change, updating player");
+                PetNicknamesChanged();
+            }
+        });
+        Mediator.Subscribe<MoodlesMessage>(this, (msg) =>
+        {
+            if (_isZoning) return;
+            var changedType = _playerRelatedObjects.FirstOrDefault(f => f.Value.Address == msg.Address);
+            if (changedType.Key == ObjectKind.Player && changedType.Value != default)
+            {
+                Logger.LogDebug("Received Moodles change, updating player");
+                MoodlesChanged();
+            }
+        });
+        Mediator.Subscribe<PenumbraModSettingChangedMessage>(this, (msg) =>
+        {
+            Logger.LogDebug("Received Penumbra Mod settings change, updating player");
+            AddPlayerCacheToCreate().GetAwaiter().GetResult();
+        });
+
+        Mediator.Subscribe<DelayedFrameworkUpdateMessage>(this, (msg) => ProcessCacheCreation());
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        _playerRelatedObjects.Values.ToList().ForEach(p => p.Dispose());
+        _cts.Dispose();
+    }
+
+    private async Task AddPlayerCacheToCreate(ObjectKind kind = ObjectKind.Player)
+    {
+        await _cacheCreateLock.WaitAsync().ConfigureAwait(false);
+        _cachesToCreate[kind] = _playerRelatedObjects[kind];
+        _cacheCreateLock.Release();
+    }
+
+    private void GlamourerChanged(ObjectKind kind)
+    {
+        if (_glamourerCts.TryGetValue(kind, out var cts))
+        {
+            _glamourerCts[kind]?.Cancel();
+            _glamourerCts[kind]?.Dispose();
+        }
+        _glamourerCts[kind] = new();
+        var token = _glamourerCts[kind].Token;
+
+        _ = Task.Run(async () =>
+        {
+            await Task.Delay(TimeSpan.FromMilliseconds(500), token).ConfigureAwait(false);
+            await AddPlayerCacheToCreate(kind).ConfigureAwait(false);
+        });
+    }
+
+    private void HonorificChanged()
+    {
+        _honorificCts?.Cancel();
+        _honorificCts?.Dispose();
+        _honorificCts = new();
+        var token = _honorificCts.Token;
+
+        _ = Task.Run(async () =>
+        {
+            await Task.Delay(TimeSpan.FromSeconds(1), token).ConfigureAwait(false);
+            await AddPlayerCacheToCreate().ConfigureAwait(false);
+        }, token);
+    }
+
+    private void PetNicknamesChanged()
+    {
+        _petNicknamesCts?.Cancel();
+        _petNicknamesCts?.Dispose();
+        _petNicknamesCts = new();
+        var token = _petNicknamesCts.Token;
+
+        _ = Task.Run(async () =>
+        {
+            await Task.Delay(TimeSpan.FromSeconds(1), token).ConfigureAwait(false);
+            await AddPlayerCacheToCreate().ConfigureAwait(false);
+        }, token);
+    }
+
+    private void MoodlesChanged()
+    {
+        _moodlesCts?.Cancel();
+        _moodlesCts?.Dispose();
+        _moodlesCts = new();
+        var token = _moodlesCts.Token;
+
+        _ = Task.Run(async () =>
+        {
+            await Task.Delay(TimeSpan.FromSeconds(1), token).ConfigureAwait(false);
+            await AddPlayerCacheToCreate().ConfigureAwait(false);
+        }, token);
+    }
+
+    private void ProcessCacheCreation()
+    {
+        if (_isZoning || _haltCharaDataCreation) return;
+
+        if (_cachesToCreate.Any() && (_cacheCreationTask?.IsCompleted ?? true))
+        {
+            _cacheCreateLock.Wait();
+            var toCreate = _cachesToCreate.ToList();
+            _cachesToCreate.Clear();
+            _cacheCreateLock.Release();
+
+            _cacheCreationTask = Task.Run(async () =>
+            {
+                try
+                {
+                    foreach (var obj in toCreate)
+                    {
+                        await _characterDataFactory.BuildCharacterData(_playerData, obj.Value, _cts.Token).ConfigureAwait(false);
+                    }
+
+                    Mediator.Publish(new CharacterDataCreatedMessage(_playerData.ToAPI()));
+                }
+                catch (Exception ex)
+                {
+                    Logger.LogCritical(ex, "Error during Cache Creation Processing");
+                }
+                finally
+                {
+                    Logger.LogDebug("Cache Creation complete");
+                }
+            }, _cts.Token);
+        }
+        else if (_cachesToCreate.Any())
+        {
+            Logger.LogDebug("Cache Creation stored until previous creation finished");
+        }
+    }
+}
+#pragma warning restore MA0040

MareSynchronos/Plugin.cs

@@ -0,0 +1,235 @@
+using Dalamud.Game.ClientState.Objects;
+using Dalamud.Interface.ImGuiFileDialog;
+using Dalamud.Interface.Windowing;
+using Dalamud.Plugin;
+using Dalamud.Plugin.Services;
+using MareSynchronos.FileCache;
+using MareSynchronos.Interop;
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.MareConfiguration.Configurations;
+using MareSynchronos.PlayerData.Factories;
+using MareSynchronos.PlayerData.Pairs;
+using MareSynchronos.PlayerData.Services;
+using MareSynchronos.Services;
+using MareSynchronos.Services.Events;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using MareSynchronos.UI;
+using MareSynchronos.UI.Components;
+using MareSynchronos.UI.Components.Popup;
+using MareSynchronos.UI.Handlers;
+using MareSynchronos.WebAPI;
+using MareSynchronos.WebAPI.Files;
+using MareSynchronos.WebAPI.SignalR;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using MareSynchronos.Services.CharaData;
+
+using MareSynchronos;
+
+namespace ElezenSync;
+
+public sealed class Plugin : IDalamudPlugin
+{
+    private readonly IHost _host;
+
+#pragma warning disable CA2211, CS8618, MA0069, S1104, S2223
+    public static Plugin Self;
+#pragma warning restore CA2211, CS8618, MA0069, S1104, S2223
+    public Action<IFramework>? RealOnFrameworkUpdate { get; set; }
+
+    // Proxy function in the ElezenSync namespace to avoid confusion in /xlstats
+    public void OnFrameworkUpdate(IFramework framework)
+    {
+        RealOnFrameworkUpdate?.Invoke(framework);
+    }
+
+    public Plugin(IDalamudPluginInterface pluginInterface, ICommandManager commandManager, IDataManager gameData,
+        IFramework framework, IObjectTable objectTable, IClientState clientState, ICondition condition, IChatGui chatGui,
+        IGameGui gameGui, IDtrBar dtrBar, IToastGui toastGui, IPluginLog pluginLog, ITargetManager targetManager, INotificationManager notificationManager,
+        ITextureProvider textureProvider, IContextMenu contextMenu, IGameInteropProvider gameInteropProvider,
+        INamePlateGui namePlateGui, IGameConfig gameConfig, IPartyList partyList)
+    {
+        Plugin.Self = this;
+        _host = new HostBuilder()
+        .UseContentRoot(pluginInterface.ConfigDirectory.FullName)
+        .ConfigureLogging(lb =>
+        {
+            lb.ClearProviders();
+            lb.AddDalamudLogging(pluginLog);
+            lb.SetMinimumLevel(LogLevel.Trace);
+        })
+        .ConfigureServices(collection =>
+        {
+            collection.AddSingleton(new WindowSystem("MareSynchronos"));
+            collection.AddSingleton<FileDialogManager>();
+
+            // add dalamud services
+            collection.AddSingleton(_ => pluginInterface);
+            collection.AddSingleton(_ => pluginInterface.UiBuilder);
+            collection.AddSingleton(_ => commandManager);
+            collection.AddSingleton(_ => gameData);
+            collection.AddSingleton(_ => framework);
+            collection.AddSingleton(_ => objectTable);
+            collection.AddSingleton(_ => clientState);
+            collection.AddSingleton(_ => condition);
+            collection.AddSingleton(_ => chatGui);
+            collection.AddSingleton(_ => gameGui);
+            collection.AddSingleton(_ => dtrBar);
+            collection.AddSingleton(_ => toastGui);
+            collection.AddSingleton(_ => pluginLog);
+            collection.AddSingleton(_ => targetManager);
+            collection.AddSingleton(_ => notificationManager);
+            collection.AddSingleton(_ => textureProvider);
+            collection.AddSingleton(_ => contextMenu);
+            collection.AddSingleton(_ => gameInteropProvider);
+            collection.AddSingleton(_ => namePlateGui);
+            collection.AddSingleton(_ => gameConfig);
+            collection.AddSingleton(_ => partyList);
+
+            // add mare related singletons
+            collection.AddSingleton<MareMediator>();
+            collection.AddSingleton<FileCacheManager>();
+            collection.AddSingleton<ServerConfigurationManager>();
+            collection.AddSingleton<ApiController>();
+            collection.AddSingleton<PerformanceCollectorService>();
+            collection.AddSingleton<HubFactory>();
+            collection.AddSingleton<FileUploadManager>();
+            collection.AddSingleton<FileTransferOrchestrator>();
+            collection.AddSingleton<MarePlugin>();
+            collection.AddSingleton<MareProfileManager>();
+            collection.AddSingleton<GameObjectHandlerFactory>();
+            collection.AddSingleton<FileDownloadManagerFactory>();
+            collection.AddSingleton<PairHandlerFactory>();
+            collection.AddSingleton<PairAnalyzerFactory>();
+            collection.AddSingleton<PairFactory>();
+            collection.AddSingleton<XivDataAnalyzer>();
+            collection.AddSingleton<CharacterAnalyzer>();
+            collection.AddSingleton<TokenProvider>();
+            collection.AddSingleton<AccountRegistrationService>();
+            collection.AddSingleton<PluginWarningNotificationService>();
+            collection.AddSingleton<FileCompactor>();
+            collection.AddSingleton<TagHandler>();
+            collection.AddSingleton<UidDisplayHandler>();
+            collection.AddSingleton<PluginWatcherService>();
+            collection.AddSingleton<PlayerPerformanceService>();
+
+            collection.AddSingleton<CharaDataManager>();
+            collection.AddSingleton<CharaDataFileHandler>();
+            collection.AddSingleton<CharaDataCharacterHandler>();
+            collection.AddSingleton<CharaDataNearbyManager>();
+            collection.AddSingleton<CharaDataGposeTogetherManager>();
+
+            collection.AddSingleton<VfxSpawnManager>();
+            collection.AddSingleton<BlockedCharacterHandler>();
+            collection.AddSingleton<IpcProvider>();
+            collection.AddSingleton<VisibilityService>();
+            collection.AddSingleton<RepoChangeService>();
+            collection.AddSingleton<EventAggregator>();
+            collection.AddSingleton<DalamudUtilService>();
+            collection.AddSingleton<DtrEntry>();
+            collection.AddSingleton<PairManager>();
+            collection.AddSingleton<RedrawManager>();
+            collection.AddSingleton<IpcCallerPenumbra>();
+            collection.AddSingleton<IpcCallerGlamourer>();
+            collection.AddSingleton<IpcCallerCustomize>();
+            collection.AddSingleton<IpcCallerHeels>();
+            collection.AddSingleton<IpcCallerHonorific>();
+            collection.AddSingleton<IpcCallerMoodles>();
+            collection.AddSingleton<IpcCallerPetNames>();
+            collection.AddSingleton<IpcCallerBrio>();
+            collection.AddSingleton<IpcCallerMare>();
+            collection.AddSingleton<IpcManager>();
+            collection.AddSingleton<NotificationService>();
+            collection.AddSingleton<NoSnapService>();
+
+            collection.AddSingleton((s) => new MareConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new ServerConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new NotesConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new ServerTagConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new SyncshellConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new TransientConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new XivDataStorageService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new PlayerPerformanceConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new ServerBlockConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new CharaDataConfigService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton((s) => new RemoteConfigCacheService(pluginInterface.ConfigDirectory.FullName));
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<MareConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<ServerConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<NotesConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<ServerTagConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<SyncshellConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<TransientConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<XivDataStorageService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<PlayerPerformanceConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<ServerBlockConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<CharaDataConfigService>());
+            collection.AddSingleton<IConfigService<IMareConfiguration>>(s => s.GetRequiredService<RemoteConfigCacheService>());
+            collection.AddSingleton<ConfigurationMigrator>();
+            collection.AddSingleton<ConfigurationSaveService>();
+            collection.AddSingleton<RemoteConfigurationService>();
+
+            collection.AddSingleton<HubFactory>();
+
+            // add scoped services
+            collection.AddScoped<CacheMonitor>();
+            collection.AddScoped<UiFactory>();
+            collection.AddScoped<WindowMediatorSubscriberBase, SettingsUi>();
+            collection.AddScoped<WindowMediatorSubscriberBase, CompactUi>();
+            collection.AddScoped<WindowMediatorSubscriberBase, IntroUi>();
+            collection.AddScoped<WindowMediatorSubscriberBase, DownloadUi>();
+            collection.AddScoped<WindowMediatorSubscriberBase, PopoutProfileUi>();
+            collection.AddScoped<WindowMediatorSubscriberBase, DataAnalysisUi>();
+            collection.AddScoped<WindowMediatorSubscriberBase, EventViewerUI>();
+            collection.AddScoped<WindowMediatorSubscriberBase, CharaDataHubUi>();
+            collection.AddScoped<WindowMediatorSubscriberBase, EditProfileUi>();
+            collection.AddScoped<WindowMediatorSubscriberBase, PopupHandler>();
+            collection.AddScoped<IPopupHandler, ReportPopupHandler>();
+            collection.AddScoped<IPopupHandler, BanUserPopupHandler>();
+            collection.AddScoped<CacheCreationService>();
+            collection.AddScoped<TransientResourceManager>();
+            collection.AddScoped<PlayerDataFactory>();
+            collection.AddScoped<OnlinePlayerManager>();
+            collection.AddScoped<UiService>();
+            collection.AddScoped<CommandManagerService>();
+            collection.AddScoped<UiSharedService>();
+            collection.AddScoped<ChatService>();
+            collection.AddScoped<GuiHookService>();
+
+            collection.AddHostedService(p => p.GetRequiredService<PluginWatcherService>());
+            collection.AddHostedService(p => p.GetRequiredService<ConfigurationSaveService>());
+            collection.AddHostedService(p => p.GetRequiredService<MareMediator>());
+            collection.AddHostedService(p => p.GetRequiredService<NotificationService>());
+            collection.AddHostedService(p => p.GetRequiredService<FileCacheManager>());
+            collection.AddHostedService(p => p.GetRequiredService<ConfigurationMigrator>());
+            collection.AddHostedService(p => p.GetRequiredService<DalamudUtilService>());
+            collection.AddHostedService(p => p.GetRequiredService<PerformanceCollectorService>());
+            collection.AddHostedService(p => p.GetRequiredService<DtrEntry>());
+            collection.AddHostedService(p => p.GetRequiredService<EventAggregator>());
+            collection.AddHostedService(p => p.GetRequiredService<MarePlugin>());
+            collection.AddHostedService(p => p.GetRequiredService<IpcProvider>());
+            collection.AddHostedService(p => p.GetRequiredService<RepoChangeService>());
+            collection.AddHostedService(p => p.GetRequiredService<NoSnapService>());
+        })
+        .Build();
+
+        _ = Task.Run(async () => {
+            try
+            {
+                await _host.StartAsync().ConfigureAwait(false);
+            }
+            catch (Exception e)
+            {
+                pluginLog.Error(e, "HostBuilder startup exception");
+            }
+        }).ConfigureAwait(false);
+    }
+
+    public void Dispose()
+    {
+        _host.StopAsync().GetAwaiter().GetResult();
+        _host.Dispose();
+    }
+}

MareSynchronos/Services/CharaData/CharaDataCharacterHandler.cs

@@ -0,0 +1,156 @@
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.PlayerData.Factories;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services.CharaData.Models;
+using MareSynchronos.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Services;
+
+public sealed class CharaDataCharacterHandler : DisposableMediatorSubscriberBase
+{
+    private readonly GameObjectHandlerFactory _gameObjectHandlerFactory;
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly IpcManager _ipcManager;
+    private readonly NoSnapService _noSnapService;
+    private readonly Dictionary<string, HandledCharaDataEntry> _handledCharaData = new(StringComparer.Ordinal);
+
+    public IReadOnlyDictionary<string, HandledCharaDataEntry> HandledCharaData => _handledCharaData;
+
+    public CharaDataCharacterHandler(ILogger<CharaDataCharacterHandler> logger, MareMediator mediator,
+        GameObjectHandlerFactory gameObjectHandlerFactory, DalamudUtilService dalamudUtilService,
+        IpcManager ipcManager, NoSnapService noSnapService)
+        : base(logger, mediator)
+    {
+        _gameObjectHandlerFactory = gameObjectHandlerFactory;
+        _dalamudUtilService = dalamudUtilService;
+        _ipcManager = ipcManager;
+        _noSnapService = noSnapService;
+        mediator.Subscribe<GposeEndMessage>(this, msg =>
+        {
+            foreach (var chara in _handledCharaData)
+            {
+                _ = RevertHandledChara(chara.Value);
+            }
+        });
+
+        mediator.Subscribe<CutsceneFrameworkUpdateMessage>(this, (_) => HandleCutsceneFrameworkUpdate());
+    }
+
+    private void HandleCutsceneFrameworkUpdate()
+    {
+        if (!_dalamudUtilService.IsInGpose) return;
+
+        foreach (var entry in _handledCharaData.Values.ToList())
+        {
+            var chara = _dalamudUtilService.GetGposeCharacterFromObjectTableByName(entry.Name, onlyGposeCharacters: true);
+            if (chara is null)
+            {
+                _handledCharaData.Remove(entry.Name);
+                _ = _dalamudUtilService.RunOnFrameworkThread(() => RevertChara(entry.Name, entry.CustomizePlus));
+            }
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        foreach (var chara in _handledCharaData.Values)
+        {
+            _ = RevertHandledChara(chara);
+        }
+    }
+
+    public HandledCharaDataEntry? GetHandledCharacter(string name)
+    {
+        return _handledCharaData.GetValueOrDefault(name);
+    }
+
+    public async Task RevertChara(string name, Guid? cPlusId)
+    {
+        Guid applicationId = Guid.NewGuid();
+        await _ipcManager.Glamourer.RevertByNameAsync(Logger, name, applicationId).ConfigureAwait(false);
+        if (cPlusId != null)
+        {
+            await _ipcManager.CustomizePlus.RevertByIdAsync(cPlusId).ConfigureAwait(false);
+        }
+        using var handler = await _gameObjectHandlerFactory.Create(ObjectKind.Player,
+            () => _dalamudUtilService.GetGposeCharacterFromObjectTableByName(name, _dalamudUtilService.IsInGpose)?.Address ?? IntPtr.Zero, false)
+            .ConfigureAwait(false);
+        if (handler.Address != nint.Zero)
+            await _ipcManager.Penumbra.RedrawAsync(Logger, handler, applicationId, CancellationToken.None).ConfigureAwait(false);
+    }
+
+    public async Task<bool> RevertHandledChara(string name)
+    {
+        var handled = _handledCharaData.GetValueOrDefault(name);
+        return await RevertHandledChara(handled).ConfigureAwait(false);
+    }
+
+    public async Task<bool> RevertHandledChara(HandledCharaDataEntry? handled)
+    {
+        if (handled == null) return false;
+        _handledCharaData.Remove(handled.Name);
+        await _dalamudUtilService.RunOnFrameworkThread(async () =>
+        {
+            RemoveGposer(handled);
+            await RevertChara(handled.Name, handled.CustomizePlus).ConfigureAwait(false);
+        }).ConfigureAwait(false);
+        return true;
+    }
+
+    internal void AddHandledChara(HandledCharaDataEntry handledCharaDataEntry)
+    {
+        _handledCharaData.Add(handledCharaDataEntry.Name, handledCharaDataEntry);
+        _ = _dalamudUtilService.RunOnFrameworkThread(() => AddGposer(handledCharaDataEntry));
+    }
+
+    public void UpdateHandledData(Dictionary<string, CharaDataMetaInfoExtendedDto?> newData)
+    {
+        foreach (var handledData in _handledCharaData.Values)
+        {
+            if (newData.TryGetValue(handledData.MetaInfo.FullId, out var metaInfo) && metaInfo != null)
+            {
+                handledData.MetaInfo = metaInfo;
+            }
+        }
+    }
+
+    public async Task<GameObjectHandler?> TryCreateGameObjectHandler(string name, bool gPoseOnly = false)
+    {
+        var handler = await _gameObjectHandlerFactory.Create(ObjectKind.Player,
+            () => _dalamudUtilService.GetGposeCharacterFromObjectTableByName(name, gPoseOnly && _dalamudUtilService.IsInGpose)?.Address ?? IntPtr.Zero, false)
+            .ConfigureAwait(false);
+        if (handler.Address == nint.Zero) return null;
+        return handler;
+    }
+
+    public async Task<GameObjectHandler?> TryCreateGameObjectHandler(int index)
+    {
+        var handler = await _gameObjectHandlerFactory.Create(ObjectKind.Player,
+            () => _dalamudUtilService.GetCharacterFromObjectTableByIndex(index)?.Address ?? IntPtr.Zero, false)
+            .ConfigureAwait(false);
+        if (handler.Address == nint.Zero) return null;
+        return handler;
+    }
+
+    private int GetGposerObjectIndex(string name)
+    {
+        return _dalamudUtilService.GetGposeCharacterFromObjectTableByName(name, _dalamudUtilService.IsInGpose)?.ObjectIndex ?? -1;
+    }
+
+    private void AddGposer(HandledCharaDataEntry handled)
+    {
+        int objectIndex = GetGposerObjectIndex(handled.Name);
+        if (objectIndex > 0)
+            _noSnapService.AddGposer(objectIndex);
+    }
+
+    private void RemoveGposer(HandledCharaDataEntry handled)
+    {
+        int objectIndex = GetGposerObjectIndex(handled.Name);
+        if (objectIndex > 0)
+            _noSnapService.RemoveGposer(objectIndex);
+    }
+}

MareSynchronos/Services/CharaData/CharaDataFileHandler.cs

@@ -0,0 +1,302 @@
+using Dalamud.Game.ClientState.Objects.SubKinds;
+using K4os.Compression.LZ4.Legacy;
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Data.Enum;
+using MareSynchronos.API.Dto.CharaData;
+using MareSynchronos.FileCache;
+using MareSynchronos.PlayerData.Factories;
+using MareSynchronos.PlayerData.Handlers;
+using MareSynchronos.Services.CharaData;
+using MareSynchronos.Services.CharaData.Models;
+using MareSynchronos.Utils;
+using MareSynchronos.WebAPI.Files;
+using Microsoft.Extensions.Logging;
+
+namespace MareSynchronos.Services;
+
+public sealed class CharaDataFileHandler : IDisposable
+{
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly FileCacheManager _fileCacheManager;
+    private readonly FileDownloadManager _fileDownloadManager;
+    private readonly FileUploadManager _fileUploadManager;
+    private readonly GameObjectHandlerFactory _gameObjectHandlerFactory;
+    private readonly ILogger<CharaDataFileHandler> _logger;
+    private readonly MareCharaFileDataFactory _mareCharaFileDataFactory;
+    private readonly PlayerDataFactory _playerDataFactory;
+    private int _globalFileCounter = 0;
+
+    public CharaDataFileHandler(ILogger<CharaDataFileHandler> logger, FileDownloadManagerFactory fileDownloadManagerFactory, FileUploadManager fileUploadManager, FileCacheManager fileCacheManager,
+            DalamudUtilService dalamudUtilService, GameObjectHandlerFactory gameObjectHandlerFactory, PlayerDataFactory playerDataFactory)
+    {
+        _fileDownloadManager = fileDownloadManagerFactory.Create();
+        _logger = logger;
+        _fileUploadManager = fileUploadManager;
+        _fileCacheManager = fileCacheManager;
+        _dalamudUtilService = dalamudUtilService;
+        _gameObjectHandlerFactory = gameObjectHandlerFactory;
+        _playerDataFactory = playerDataFactory;
+        _mareCharaFileDataFactory = new(fileCacheManager);
+    }
+
+    public void ComputeMissingFiles(CharaDataDownloadDto charaDataDownloadDto, out Dictionary<string, string> modPaths, out List<FileReplacementData> missingFiles)
+    {
+        modPaths = [];
+        missingFiles = [];
+        foreach (var file in charaDataDownloadDto.FileGamePaths)
+        {
+            var localCacheFile = _fileCacheManager.GetFileCacheByHash(file.HashOrFileSwap);
+            if (localCacheFile == null)
+            {
+                var existingFile = missingFiles.Find(f => string.Equals(f.Hash, file.HashOrFileSwap, StringComparison.Ordinal));
+                if (existingFile == null)
+                {
+                    missingFiles.Add(new FileReplacementData()
+                    {
+                        Hash = file.HashOrFileSwap,
+                        GamePaths = [file.GamePath]
+                    });
+                }
+                else
+                {
+                    existingFile.GamePaths = existingFile.GamePaths.Concat([file.GamePath]).ToArray();
+                }
+            }
+            else
+            {
+                modPaths[file.GamePath] = localCacheFile.ResolvedFilepath;
+            }
+        }
+
+        foreach (var swap in charaDataDownloadDto.FileSwaps)
+        {
+            modPaths[swap.GamePath] = swap.HashOrFileSwap;
+        }
+    }
+
+    public async Task<CharacterData?> CreatePlayerData()
+    {
+        var chara = await _dalamudUtilService.GetPlayerCharacterAsync().ConfigureAwait(false);
+        if (_dalamudUtilService.IsInGpose)
+        {
+            chara = (IPlayerCharacter?)(await _dalamudUtilService.GetGposeCharacterFromObjectTableByNameAsync(chara.Name.TextValue, _dalamudUtilService.IsInGpose).ConfigureAwait(false));
+        }
+
+        if (chara == null)
+            return null;
+
+        using var tempHandler = await _gameObjectHandlerFactory.Create(ObjectKind.Player,
+                        () => _dalamudUtilService.GetCharacterFromObjectTableByIndex(chara.ObjectIndex)?.Address ?? IntPtr.Zero, isWatched: false).ConfigureAwait(false);
+        PlayerData.Data.CharacterData newCdata = new();
+        await _playerDataFactory.BuildCharacterData(newCdata, tempHandler, CancellationToken.None).ConfigureAwait(false);
+        if (newCdata.FileReplacements.TryGetValue(ObjectKind.Player, out var playerData) && playerData != null)
+        {
+            foreach (var data in playerData.Select(g => g.GamePaths))
+            {
+                data.RemoveWhere(g => g.EndsWith(".pap", StringComparison.OrdinalIgnoreCase)
+                    || g.EndsWith(".tmb", StringComparison.OrdinalIgnoreCase)
+                    || g.EndsWith(".scd", StringComparison.OrdinalIgnoreCase)
+                    || (g.EndsWith(".avfx", StringComparison.OrdinalIgnoreCase)
+                        && !g.Contains("/weapon/", StringComparison.OrdinalIgnoreCase)
+                        && !g.Contains("/equipment/", StringComparison.OrdinalIgnoreCase))
+                    || (g.EndsWith(".atex", StringComparison.OrdinalIgnoreCase)
+                        && !g.Contains("/weapon/", StringComparison.OrdinalIgnoreCase)
+                        && !g.Contains("/equipment/", StringComparison.OrdinalIgnoreCase)));
+            }
+
+            playerData.RemoveWhere(g => g.GamePaths.Count == 0);
+        }
+
+        return newCdata.ToAPI();
+    }
+
+    public void Dispose()
+    {
+        _fileDownloadManager.Dispose();
+    }
+
+    public async Task DownloadFilesAsync(GameObjectHandler tempHandler, List<FileReplacementData> missingFiles, Dictionary<string, string> modPaths, CancellationToken token)
+    {
+        await _fileDownloadManager.InitiateDownloadList(tempHandler, missingFiles, token).ConfigureAwait(false);
+        await _fileDownloadManager.DownloadFiles(tempHandler, missingFiles, token).ConfigureAwait(false);
+        token.ThrowIfCancellationRequested();
+        foreach (var file in missingFiles.SelectMany(m => m.GamePaths, (FileEntry, GamePath) => (FileEntry.Hash, GamePath)))
+        {
+            var localFile = _fileCacheManager.GetFileCacheByHash(file.Hash)?.ResolvedFilepath;
+            if (localFile == null)
+            {
+                throw new FileNotFoundException("File not found locally.");
+            }
+            modPaths[file.GamePath] = localFile;
+        }
+    }
+
+    public Task<(MareCharaFileHeader loadedCharaFile, long expectedLength)> LoadCharaFileHeader(string filePath)
+    {
+        try
+        {
+            using var unwrapped = File.OpenRead(filePath);
+            using var lz4Stream = new LZ4Stream(unwrapped, LZ4StreamMode.Decompress, LZ4StreamFlags.HighCompression);
+            using var reader = new BinaryReader(lz4Stream);
+            var loadedCharaFile = MareCharaFileHeader.FromBinaryReader(filePath, reader);
+
+            _logger.LogInformation("Read Mare Chara File");
+            _logger.LogInformation("Version: {ver}", (loadedCharaFile?.Version ?? -1));
+            long expectedLength = 0;
+            if (loadedCharaFile != null)
+            {
+                _logger.LogTrace("Data");
+                foreach (var item in loadedCharaFile.CharaFileData.FileSwaps)
+                {
+                    foreach (var gamePath in item.GamePaths)
+                    {
+                        _logger.LogTrace("Swap: {gamePath} => {fileSwapPath}", gamePath, item.FileSwapPath);
+                    }
+                }
+
+                var itemNr = 0;
+                foreach (var item in loadedCharaFile.CharaFileData.Files)
+                {
+                    itemNr++;
+                    expectedLength += item.Length;
+                    foreach (var gamePath in item.GamePaths)
+                    {
+                        _logger.LogTrace("File {itemNr}: {gamePath} = {len}", itemNr, gamePath, item.Length.ToByteString());
+                    }
+                }
+
+                _logger.LogInformation("Expected length: {expected}", expectedLength.ToByteString());
+            }
+            else
+            {
+                throw new InvalidOperationException("MCDF Header was null");
+            }
+            return Task.FromResult((loadedCharaFile, expectedLength));
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Could not parse MCDF header of file {file}", filePath);
+            throw;
+        }
+    }
+
+    public Dictionary<string, string> McdfExtractFiles(MareCharaFileHeader? charaFileHeader, long expectedLength, List<string> extractedFiles)
+    {
+        if (charaFileHeader == null) return [];
+
+        using var lz4Stream = new LZ4Stream(File.OpenRead(charaFileHeader.FilePath), LZ4StreamMode.Decompress, LZ4StreamFlags.HighCompression);
+        using var reader = new BinaryReader(lz4Stream);
+        MareCharaFileHeader.AdvanceReaderToData(reader);
+
+        long totalRead = 0;
+        Dictionary<string, string> gamePathToFilePath = new(StringComparer.Ordinal);
+        foreach (var fileData in charaFileHeader.CharaFileData.Files)
+        {
+            var fileName = Path.Combine(_fileCacheManager.CacheFolder, "mare_" + _globalFileCounter++ + ".tmp");
+            extractedFiles.Add(fileName);
+            var length = fileData.Length;
+            var bufferSize = length;
+            using var fs = File.OpenWrite(fileName);
+            using var wr = new BinaryWriter(fs);
+            _logger.LogTrace("Reading {length} of {fileName}", length.ToByteString(), fileName);
+            var buffer = reader.ReadBytes(bufferSize);
+            wr.Write(buffer);
+            wr.Flush();
+            wr.Close();
+            if (buffer.Length == 0) throw new EndOfStreamException("Unexpected EOF");
+            foreach (var path in fileData.GamePaths)
+            {
+                gamePathToFilePath[path] = fileName;
+                _logger.LogTrace("{path} => {fileName} [{hash}]", path, fileName, fileData.Hash);
+            }
+            totalRead += length;
+            _logger.LogTrace("Read {read}/{expected} bytes", totalRead.ToByteString(), expectedLength.ToByteString());
+        }
+
+        return gamePathToFilePath;
+    }
+
+    public async Task UpdateCharaDataAsync(CharaDataExtendedUpdateDto updateDto)
+    {
+        var data = await CreatePlayerData().ConfigureAwait(false);
+
+        if (data != null)
+        {
+            var hasGlamourerData = data.GlamourerData.TryGetValue(ObjectKind.Player, out var playerDataString);
+            if (!hasGlamourerData) updateDto.GlamourerData = null;
+            else updateDto.GlamourerData = playerDataString;
+
+            var hasCustomizeData = data.CustomizePlusData.TryGetValue(ObjectKind.Player, out var customizeDataString);
+            if (!hasCustomizeData) updateDto.CustomizeData = null;
+            else updateDto.CustomizeData = customizeDataString;
+
+            updateDto.ManipulationData = data.ManipulationData;
+
+            var hasFiles = data.FileReplacements.TryGetValue(ObjectKind.Player, out var fileReplacements);
+            if (!hasFiles)
+            {
+                updateDto.FileGamePaths = [];
+                updateDto.FileSwaps = [];
+            }
+            else
+            {
+                updateDto.FileGamePaths = [.. fileReplacements!.Where(u => string.IsNullOrEmpty(u.FileSwapPath)).SelectMany(u => u.GamePaths, (file, path) => new GamePathEntry(file.Hash, path))];
+                updateDto.FileSwaps = [.. fileReplacements!.Where(u => !string.IsNullOrEmpty(u.FileSwapPath)).SelectMany(u => u.GamePaths, (file, path) => new GamePathEntry(file.FileSwapPath, path))];
+            }
+        }
+    }
+
+    internal async Task SaveCharaFileAsync(string description, string filePath)
+    {
+        var tempFilePath = filePath + ".tmp";
+
+        try
+        {
+            var data = await CreatePlayerData().ConfigureAwait(false);
+            if (data == null) return;
+
+            var mareCharaFileData = _mareCharaFileDataFactory.Create(description, data);
+            MareCharaFileHeader output = new(MareCharaFileHeader.CurrentVersion, mareCharaFileData);
+
+            using var fs = new FileStream(tempFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.None);
+            using var lz4 = new LZ4Stream(fs, LZ4StreamMode.Compress, LZ4StreamFlags.HighCompression);
+            using var writer = new BinaryWriter(lz4);
+            output.WriteToStream(writer);
+
+            foreach (var item in output.CharaFileData.Files)
+            {
+                var file = _fileCacheManager.GetFileCacheByHash(item.Hash)!;
+                _logger.LogDebug("Saving to MCDF: {hash}:{file}", item.Hash, file.ResolvedFilepath);
+                _logger.LogDebug("\tAssociated GamePaths:");
+                foreach (var path in item.GamePaths)
+                {
+                    _logger.LogDebug("\t{path}", path);
+                }
+
+                var fsRead = File.OpenRead(file.ResolvedFilepath);
+                await using (fsRead.ConfigureAwait(false))
+                {
+                    using var br = new BinaryReader(fsRead);
+                    byte[] buffer = new byte[item.Length];
+                    br.Read(buffer, 0, item.Length);
+                    writer.Write(buffer);
+                }
+            }
+            writer.Flush();
+            await lz4.FlushAsync().ConfigureAwait(false);
+            await fs.FlushAsync().ConfigureAwait(false);
+            fs.Close();
+            File.Move(tempFilePath, filePath, true);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failure Saving Mare Chara File, deleting output");
+            File.Delete(tempFilePath);
+        }
+    }
+
+    internal async Task<List<string>> UploadFiles(List<string> fileList, ValueProgress<string> uploadProgress, CancellationToken token)
+    {
+        return await _fileUploadManager.UploadFiles(fileList, uploadProgress, token).ConfigureAwait(false);
+    }
+}

MareSynchronos/Services/CharaData/CharaDataGposeTogetherManager.cs

@@ -0,0 +1,696 @@
+using Dalamud.Game.ClientState.Objects.SubKinds;
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Dto.CharaData;
+using MareSynchronos.Interop;
+using MareSynchronos.Interop.Ipc;
+using MareSynchronos.Services.CharaData.Models;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.WebAPI;
+using Microsoft.Extensions.Logging;
+using System.Globalization;
+using System.Numerics;
+using System.Text.Json.Nodes;
+
+namespace MareSynchronos.Services.CharaData;
+
+public class CharaDataGposeTogetherManager : DisposableMediatorSubscriberBase
+{
+    private readonly ApiController _apiController;
+    private readonly IpcCallerBrio _brio;
+    private readonly SemaphoreSlim _charaDataCreationSemaphore = new(1, 1);
+    private readonly CharaDataFileHandler _charaDataFileHandler;
+    private readonly CharaDataManager _charaDataManager;
+    private readonly DalamudUtilService _dalamudUtil;
+    private readonly Dictionary<string, GposeLobbyUserData> _usersInLobby = [];
+    private readonly VfxSpawnManager _vfxSpawnManager;
+    private (CharacterData ApiData, CharaDataDownloadDto Dto)? _lastCreatedCharaData;
+    private PoseData? _lastDeltaPoseData;
+    private PoseData? _lastFullPoseData;
+    private WorldData? _lastWorldData;
+    private CancellationTokenSource _lobbyCts = new();
+    private int _poseGenerationExecutions = 0;
+
+    public CharaDataGposeTogetherManager(ILogger<CharaDataGposeTogetherManager> logger, MareMediator mediator,
+            ApiController apiController, IpcCallerBrio brio, DalamudUtilService dalamudUtil, VfxSpawnManager vfxSpawnManager,
+        CharaDataFileHandler charaDataFileHandler, CharaDataManager charaDataManager) : base(logger, mediator)
+    {
+        Mediator.Subscribe<GposeLobbyUserJoin>(this, (msg) =>
+        {
+            OnUserJoinLobby(msg.UserData);
+        });
+        Mediator.Subscribe<GPoseLobbyUserLeave>(this, (msg) =>
+        {
+            OnUserLeaveLobby(msg.UserData);
+        });
+        Mediator.Subscribe<GPoseLobbyReceiveCharaData>(this, (msg) =>
+        {
+            OnReceiveCharaData(msg.CharaDataDownloadDto);
+        });
+        Mediator.Subscribe<GPoseLobbyReceivePoseData>(this, (msg) =>
+        {
+            OnReceivePoseData(msg.UserData, msg.PoseData);
+        });
+        Mediator.Subscribe<GPoseLobbyReceiveWorldData>(this, (msg) =>
+        {
+            OnReceiveWorldData(msg.UserData, msg.WorldData);
+        });
+        Mediator.Subscribe<ConnectedMessage>(this, (msg) =>
+        {
+            if (_usersInLobby.Count > 0 && !string.IsNullOrEmpty(CurrentGPoseLobbyId))
+            {
+                JoinGPoseLobby(CurrentGPoseLobbyId, isReconnecting: true);
+            }
+            else
+            {
+                LeaveGPoseLobby();
+            }
+        });
+        Mediator.Subscribe<GposeStartMessage>(this, (msg) =>
+        {
+            OnEnterGpose();
+        });
+        Mediator.Subscribe<GposeEndMessage>(this, (msg) =>
+        {
+            OnExitGpose();
+        });
+        Mediator.Subscribe<FrameworkUpdateMessage>(this, (msg) =>
+        {
+            OnFrameworkUpdate();
+        });
+        Mediator.Subscribe<CutsceneFrameworkUpdateMessage>(this, (msg) =>
+        {
+            OnCutsceneFrameworkUpdate();
+        });
+        Mediator.Subscribe<DisconnectedMessage>(this, (msg) =>
+        {
+            LeaveGPoseLobby();
+        });
+
+        _apiController = apiController;
+        _brio = brio;
+        _dalamudUtil = dalamudUtil;
+        _vfxSpawnManager = vfxSpawnManager;
+        _charaDataFileHandler = charaDataFileHandler;
+        _charaDataManager = charaDataManager;
+    }
+
+    public string? CurrentGPoseLobbyId { get; private set; }
+    public string? LastGPoseLobbyId { get; private set; }
+
+    public IEnumerable<GposeLobbyUserData> UsersInLobby => _usersInLobby.Values;
+
+    public (bool SameMap, bool SameServer, bool SameEverything) IsOnSameMapAndServer(GposeLobbyUserData data)
+    {
+        return (data.Map.RowId == _lastWorldData?.LocationInfo.MapId, data.WorldData?.LocationInfo.ServerId == _lastWorldData?.LocationInfo.ServerId, data.WorldData?.LocationInfo == _lastWorldData?.LocationInfo);
+    }
+
+    public async Task PushCharacterDownloadDto()
+    {
+        var playerData = await _charaDataFileHandler.CreatePlayerData().ConfigureAwait(false);
+        if (playerData == null) return;
+        if (!string.Equals(playerData.DataHash.Value, _lastCreatedCharaData?.ApiData.DataHash.Value, StringComparison.Ordinal))
+        {
+            List<GamePathEntry> filegamePaths = [.. playerData.FileReplacements[API.Data.Enum.ObjectKind.Player]
+            .Where(u => string.IsNullOrEmpty(u.FileSwapPath)).SelectMany(u => u.GamePaths, (file, path) => new GamePathEntry(file.Hash, path))];
+            List<GamePathEntry> fileSwapPaths = [.. playerData.FileReplacements[API.Data.Enum.ObjectKind.Player]
+            .Where(u => !string.IsNullOrEmpty(u.FileSwapPath)).SelectMany(u => u.GamePaths, (file, path) => new GamePathEntry(file.FileSwapPath, path))];
+            await _charaDataManager.UploadFiles([.. playerData.FileReplacements[API.Data.Enum.ObjectKind.Player]
+            .Where(u => string.IsNullOrEmpty(u.FileSwapPath)).SelectMany(u => u.GamePaths, (file, path) => new GamePathEntry(file.Hash, path))])
+                .ConfigureAwait(false);
+
+            CharaDataDownloadDto charaDataDownloadDto = new($"GPOSELOBBY:{CurrentGPoseLobbyId}", new(_apiController.UID))
+            {
+                UpdatedDate = DateTime.UtcNow,
+                ManipulationData = playerData.ManipulationData,
+                CustomizeData = playerData.CustomizePlusData[API.Data.Enum.ObjectKind.Player],
+                FileGamePaths = filegamePaths,
+                FileSwaps = fileSwapPaths,
+                GlamourerData = playerData.GlamourerData[API.Data.Enum.ObjectKind.Player],
+            };
+
+            _lastCreatedCharaData = (playerData, charaDataDownloadDto);
+        }
+
+        ForceResendOwnData();
+
+        if (_lastCreatedCharaData != null)
+            await _apiController.GposeLobbyPushCharacterData(_lastCreatedCharaData.Value.Dto)
+                .ConfigureAwait(false);
+    }
+
+    internal void CreateNewLobby()
+    {
+        _ = Task.Run(async () =>
+        {
+            ClearLobby();
+            CurrentGPoseLobbyId = await _apiController.GposeLobbyCreate().ConfigureAwait(false);
+            if (!string.IsNullOrEmpty(CurrentGPoseLobbyId))
+            {
+                _ = GposeWorldPositionBackgroundTask(_lobbyCts.Token);
+                _ = GposePoseDataBackgroundTask(_lobbyCts.Token);
+            }
+        });
+    }
+
+    internal void JoinGPoseLobby(string joinLobbyId, bool isReconnecting = false)
+    {
+        _ = Task.Run(async () =>
+        {
+            var otherUsers = await _apiController.GposeLobbyJoin(joinLobbyId).ConfigureAwait(false);
+            ClearLobby();
+            if (otherUsers.Any())
+            {
+                LastGPoseLobbyId = string.Empty;
+
+                foreach (var user in otherUsers)
+                {
+                    OnUserJoinLobby(user);
+                }
+
+                CurrentGPoseLobbyId = joinLobbyId;
+                _ = GposeWorldPositionBackgroundTask(_lobbyCts.Token);
+                _ = GposePoseDataBackgroundTask(_lobbyCts.Token);
+            }
+            else
+            {
+                LeaveGPoseLobby();
+                LastGPoseLobbyId = string.Empty;
+            }
+        });
+    }
+
+    internal void LeaveGPoseLobby()
+    {
+        _ = Task.Run(async () =>
+        {
+            var left = await _apiController.GposeLobbyLeave().ConfigureAwait(false);
+            if (left)
+            {
+                if (_usersInLobby.Count != 0)
+                {
+                    LastGPoseLobbyId = CurrentGPoseLobbyId;
+                }
+
+                ClearLobby(revertCharas: true);
+            }
+        });
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        if (disposing)
+        {
+            ClearLobby(revertCharas: true);
+        }
+    }
+
+    private void ClearLobby(bool revertCharas = false)
+    {
+        _lobbyCts.Cancel();
+        _lobbyCts.Dispose();
+        _lobbyCts = new();
+        CurrentGPoseLobbyId = string.Empty;
+        foreach (var user in _usersInLobby.ToDictionary())
+        {
+            if (revertCharas)
+                _charaDataManager.RevertChara(user.Value.HandledChara);
+            OnUserLeaveLobby(user.Value.UserData);
+        }
+        _usersInLobby.Clear();
+    }
+
+    private string CreateJsonFromPoseData(PoseData? poseData)
+    {
+        if (poseData == null) return "{}";
+
+        var node = new JsonObject();
+        node["Bones"] = new JsonObject();
+        foreach (var bone in poseData.Value.Bones)
+        {
+            node["Bones"]![bone.Key] = new JsonObject();
+            node["Bones"]![bone.Key]!["Position"] = $"{bone.Value.PositionX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.PositionY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.PositionZ.ToString(CultureInfo.InvariantCulture)}";
+            node["Bones"]![bone.Key]!["Scale"] = $"{bone.Value.ScaleX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.ScaleY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.ScaleZ.ToString(CultureInfo.InvariantCulture)}";
+            node["Bones"]![bone.Key]!["Rotation"] = $"{bone.Value.RotationX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationZ.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationW.ToString(CultureInfo.InvariantCulture)}";
+        }
+        node["MainHand"] = new JsonObject();
+        foreach (var bone in poseData.Value.MainHand)
+        {
+            node["MainHand"]![bone.Key] = new JsonObject();
+            node["MainHand"]![bone.Key]!["Position"] = $"{bone.Value.PositionX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.PositionY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.PositionZ.ToString(CultureInfo.InvariantCulture)}";
+            node["MainHand"]![bone.Key]!["Scale"] = $"{bone.Value.ScaleX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.ScaleY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.ScaleZ.ToString(CultureInfo.InvariantCulture)}";
+            node["MainHand"]![bone.Key]!["Rotation"] = $"{bone.Value.RotationX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationZ.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationW.ToString(CultureInfo.InvariantCulture)}";
+        }
+        node["OffHand"] = new JsonObject();
+        foreach (var bone in poseData.Value.OffHand)
+        {
+            node["OffHand"]![bone.Key] = new JsonObject();
+            node["OffHand"]![bone.Key]!["Position"] = $"{bone.Value.PositionX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.PositionY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.PositionZ.ToString(CultureInfo.InvariantCulture)}";
+            node["OffHand"]![bone.Key]!["Scale"] = $"{bone.Value.ScaleX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.ScaleY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.ScaleZ.ToString(CultureInfo.InvariantCulture)}";
+            node["OffHand"]![bone.Key]!["Rotation"] = $"{bone.Value.RotationX.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationY.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationZ.ToString(CultureInfo.InvariantCulture)}, {bone.Value.RotationW.ToString(CultureInfo.InvariantCulture)}";
+        }
+
+        return node.ToJsonString();
+    }
+
+    private PoseData CreatePoseDataFromJson(string json, PoseData? fullPoseData = null)
+    {
+        PoseData output = new();
+        output.Bones = new(StringComparer.Ordinal);
+        output.MainHand = new(StringComparer.Ordinal);
+        output.OffHand = new(StringComparer.Ordinal);
+
+        float getRounded(string number)
+        {
+            return float.Round(float.Parse(number, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture), 5);
+        }
+
+        BoneData createBoneData(JsonNode boneJson)
+        {
+            BoneData outputBoneData = new();
+            outputBoneData.Exists = true;
+            var posString = boneJson["Position"]!.ToString();
+            var pos = posString.Split(",", StringSplitOptions.TrimEntries);
+            outputBoneData.PositionX = getRounded(pos[0]);
+            outputBoneData.PositionY = getRounded(pos[1]);
+            outputBoneData.PositionZ = getRounded(pos[2]);
+
+            var scaString = boneJson["Scale"]!.ToString();
+            var sca = scaString.Split(",", StringSplitOptions.TrimEntries);
+            outputBoneData.ScaleX = getRounded(sca[0]);
+            outputBoneData.ScaleY = getRounded(sca[1]);
+            outputBoneData.ScaleZ = getRounded(sca[2]);
+
+            var rotString = boneJson["Rotation"]!.ToString();
+            var rot = rotString.Split(",", StringSplitOptions.TrimEntries);
+            outputBoneData.RotationX = getRounded(rot[0]);
+            outputBoneData.RotationY = getRounded(rot[1]);
+            outputBoneData.RotationZ = getRounded(rot[2]);
+            outputBoneData.RotationW = getRounded(rot[3]);
+            return outputBoneData;
+        }
+
+        var node = JsonNode.Parse(json)!;
+        var bones = node["Bones"]!.AsObject();
+        foreach (var bone in bones)
+        {
+            string name = bone.Key;
+            var boneJson = bone.Value!.AsObject();
+            BoneData outputBoneData = createBoneData(boneJson);
+
+            if (fullPoseData != null)
+            {
+                if (fullPoseData.Value.Bones.TryGetValue(name, out var prevBoneData) && prevBoneData != outputBoneData)
+                {
+                    output.Bones[name] = outputBoneData;
+                }
+            }
+            else
+            {
+                output.Bones[name] = outputBoneData;
+            }
+        }
+        var mainHand = node["MainHand"]!.AsObject();
+        foreach (var bone in mainHand)
+        {
+            string name = bone.Key;
+            var boneJson = bone.Value!.AsObject();
+            BoneData outputBoneData = createBoneData(boneJson);
+
+            if (fullPoseData != null)
+            {
+                if (fullPoseData.Value.MainHand.TryGetValue(name, out var prevBoneData) && prevBoneData != outputBoneData)
+                {
+                    output.MainHand[name] = outputBoneData;
+                }
+            }
+            else
+            {
+                output.MainHand[name] = outputBoneData;
+            }
+        }
+        var offhand = node["OffHand"]!.AsObject();
+        foreach (var bone in offhand)
+        {
+            string name = bone.Key;
+            var boneJson = bone.Value!.AsObject();
+            BoneData outputBoneData = createBoneData(boneJson);
+
+            if (fullPoseData != null)
+            {
+                if (fullPoseData.Value.OffHand.TryGetValue(name, out var prevBoneData) && prevBoneData != outputBoneData)
+                {
+                    output.OffHand[name] = outputBoneData;
+                }
+            }
+            else
+            {
+                output.OffHand[name] = outputBoneData;
+            }
+        }
+
+        if (fullPoseData != null)
+            output.IsDelta = true;
+
+        return output;
+    }
+
+    private async Task GposePoseDataBackgroundTask(CancellationToken ct)
+    {
+        _lastFullPoseData = null;
+        _lastDeltaPoseData = null;
+        _poseGenerationExecutions = 0;
+
+        while (!ct.IsCancellationRequested)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(2), ct).ConfigureAwait(false);
+            if (!_dalamudUtil.IsInGpose) continue;
+            if (_usersInLobby.Count == 0) continue;
+
+            try
+            {
+                var chara = await _dalamudUtil.GetPlayerCharacterAsync().ConfigureAwait(false);
+                if (_dalamudUtil.IsInGpose)
+                {
+                    chara = (IPlayerCharacter?)(await _dalamudUtil.GetGposeCharacterFromObjectTableByNameAsync(chara.Name.TextValue, _dalamudUtil.IsInGpose).ConfigureAwait(false));
+                }
+                if (chara == null || chara.Address == nint.Zero) continue;
+
+                var poseJson = await _brio.GetPoseAsync(chara.Address).ConfigureAwait(false);
+                if (string.IsNullOrEmpty(poseJson)) continue;
+
+                var lastFullData = _poseGenerationExecutions++ >= 12 ? null : _lastFullPoseData;
+                lastFullData = _forceResendFullPose ? _lastFullPoseData : lastFullData;
+
+                var poseData = CreatePoseDataFromJson(poseJson, lastFullData);
+                if (!poseData.IsDelta)
+                {
+                    _lastFullPoseData = poseData;
+                    _lastDeltaPoseData = null;
+                    _poseGenerationExecutions = 0;
+                }
+
+                bool deltaIsSame = _lastDeltaPoseData != null &&
+                    (poseData.Bones.Keys.All(k => _lastDeltaPoseData.Value.Bones.ContainsKey(k)
+                        && poseData.Bones.Values.All(k => _lastDeltaPoseData.Value.Bones.ContainsValue(k))));
+
+                if (_forceResendFullPose || ((poseData.Bones.Any() || poseData.MainHand.Any() || poseData.OffHand.Any())
+                    && (!poseData.IsDelta || (poseData.IsDelta && !deltaIsSame))))
+                {
+                    _forceResendFullPose = false;
+                    await _apiController.GposeLobbyPushPoseData(poseData).ConfigureAwait(false);
+                }
+
+                if (poseData.IsDelta)
+                    _lastDeltaPoseData = poseData;
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning(ex, "Error during Pose Data Generation");
+            }
+        }
+    }
+
+    private async Task GposeWorldPositionBackgroundTask(CancellationToken ct)
+    {
+        while (!ct.IsCancellationRequested)
+        {
+            await Task.Delay(TimeSpan.FromSeconds(_dalamudUtil.IsInGpose ? 2 : 1), ct).ConfigureAwait(false);
+
+            // if there are no players in lobby, don't do anything
+            if (_usersInLobby.Count == 0) continue;
+
+            try
+            {
+                // get own player data
+                var player = (Dalamud.Game.ClientState.Objects.Types.ICharacter?)(await _dalamudUtil.GetPlayerCharacterAsync().ConfigureAwait(false));
+                if (player == null) continue;
+                WorldData worldData;
+                if (_dalamudUtil.IsInGpose)
+                {
+                    player = await _dalamudUtil.GetGposeCharacterFromObjectTableByNameAsync(player.Name.TextValue, true).ConfigureAwait(false);
+                    if (player == null) continue;
+                    worldData = (await _brio.GetTransformAsync(player.Address).ConfigureAwait(false));
+                }
+                else
+                {
+                    var rotQuaternion = Quaternion.CreateFromAxisAngle(new Vector3(0, 1, 0), player.Rotation);
+                    worldData = new()
+                    {
+                        PositionX = player.Position.X,
+                        PositionY = player.Position.Y,
+                        PositionZ = player.Position.Z,
+                        RotationW = rotQuaternion.W,
+                        RotationX = rotQuaternion.X,
+                        RotationY = rotQuaternion.Y,
+                        RotationZ = rotQuaternion.Z,
+                        ScaleX = 1,
+                        ScaleY = 1,
+                        ScaleZ = 1
+                    };
+                }
+
+                var loc = await _dalamudUtil.GetMapDataAsync().ConfigureAwait(false);
+                worldData.LocationInfo = loc;
+
+                if (_forceResendWorldData || worldData != _lastWorldData)
+                {
+                    _forceResendWorldData = false;
+                    await _apiController.GposeLobbyPushWorldData(worldData).ConfigureAwait(false);
+                    _lastWorldData = worldData;
+                    Logger.LogTrace("WorldData (gpose: {gpose}): {data}", _dalamudUtil.IsInGpose, worldData);
+                }
+
+                foreach (var entry in _usersInLobby)
+                {
+                    if (!entry.Value.HasWorldDataUpdate || _dalamudUtil.IsInGpose || entry.Value.WorldData == null) continue;
+
+                    var entryWorldData = entry.Value.WorldData!.Value;
+
+                    if (worldData.LocationInfo.MapId == entryWorldData.LocationInfo.MapId && worldData.LocationInfo.DivisionId == entryWorldData.LocationInfo.DivisionId
+                        && (worldData.LocationInfo.HouseId != entryWorldData.LocationInfo.HouseId
+                        || worldData.LocationInfo.WardId != entryWorldData.LocationInfo.WardId
+                        || entryWorldData.LocationInfo.ServerId != worldData.LocationInfo.ServerId))
+                    {
+                        if (entry.Value.SpawnedVfxId == null)
+                        {
+                            // spawn if it doesn't exist yet
+                            entry.Value.LastWorldPosition = new Vector3(entryWorldData.PositionX, entryWorldData.PositionY, entryWorldData.PositionZ);
+                            entry.Value.SpawnedVfxId = await _dalamudUtil.RunOnFrameworkThread(() => _vfxSpawnManager.SpawnObject(entry.Value.LastWorldPosition.Value,
+                                Quaternion.Identity, Vector3.One, 0.5f, 0.1f, 0.5f, 0.9f)).ConfigureAwait(false);
+                        }
+                        else
+                        {
+                            // move object via lerp if it does exist
+                            var newPosition = new Vector3(entryWorldData.PositionX, entryWorldData.PositionY, entryWorldData.PositionZ);
+                            if (newPosition != entry.Value.LastWorldPosition)
+                            {
+                                entry.Value.UpdateStart = DateTime.UtcNow;
+                                entry.Value.TargetWorldPosition = newPosition;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        await _dalamudUtil.RunOnFrameworkThread(() => _vfxSpawnManager.DespawnObject(entry.Value.SpawnedVfxId)).ConfigureAwait(false);
+                        entry.Value.SpawnedVfxId = null;
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Logger.LogWarning(ex, "Error during World Data Generation");
+            }
+        }
+    }
+
+    private void OnCutsceneFrameworkUpdate()
+    {
+        foreach (var kvp in _usersInLobby)
+        {
+            if (!string.IsNullOrWhiteSpace(kvp.Value.AssociatedCharaName))
+            {
+                kvp.Value.Address = _dalamudUtil.GetGposeCharacterFromObjectTableByName(kvp.Value.AssociatedCharaName, true)?.Address ?? nint.Zero;
+                if (kvp.Value.Address == nint.Zero)
+                {
+                    kvp.Value.AssociatedCharaName = string.Empty;
+                }
+            }
+
+            if (kvp.Value.Address != nint.Zero && (kvp.Value.HasWorldDataUpdate || kvp.Value.HasPoseDataUpdate))
+            {
+                bool hadPoseDataUpdate = kvp.Value.HasPoseDataUpdate;
+                bool hadWorldDataUpdate = kvp.Value.HasWorldDataUpdate;
+                kvp.Value.HasPoseDataUpdate = false;
+                kvp.Value.HasWorldDataUpdate = false;
+
+                _ = Task.Run(async () =>
+                {
+                    if (hadPoseDataUpdate && kvp.Value.ApplicablePoseData != null)
+                    {
+                        await _brio.SetPoseAsync(kvp.Value.Address, CreateJsonFromPoseData(kvp.Value.ApplicablePoseData)).ConfigureAwait(false);
+                    }
+                    if (hadWorldDataUpdate && kvp.Value.WorldData != null)
+                    {
+                        await _brio.ApplyTransformAsync(kvp.Value.Address, kvp.Value.WorldData.Value).ConfigureAwait(false);
+                    }
+                });
+            }
+        }
+    }
+
+    private void OnEnterGpose()
+    {
+        ForceResendOwnData();
+        ResetOwnData();
+        foreach (var data in _usersInLobby.Values)
+        {
+            _ = _dalamudUtil.RunOnFrameworkThread(() => _vfxSpawnManager.DespawnObject(data.SpawnedVfxId));
+            data.Reset();
+        }
+    }
+
+    private void OnExitGpose()
+    {
+        ForceResendOwnData();
+        ResetOwnData();
+        foreach (var data in _usersInLobby.Values)
+        {
+            data.Reset();
+        }
+    }
+
+
+    private bool _forceResendFullPose = false;
+    private bool _forceResendWorldData = false;
+
+    private void ForceResendOwnData()
+    {
+        _forceResendFullPose = true;
+        _forceResendWorldData = true;
+    }
+
+    private void ResetOwnData()
+    {
+        _poseGenerationExecutions = 0;
+        _lastCreatedCharaData = null;
+    }
+
+    private void OnFrameworkUpdate()
+    {
+        var frameworkTime = DateTime.UtcNow;
+        foreach (var kvp in _usersInLobby)
+        {
+            if (kvp.Value.SpawnedVfxId != null && kvp.Value.UpdateStart != null)
+            {
+                var secondsElasped = frameworkTime.Subtract(kvp.Value.UpdateStart.Value).TotalSeconds;
+                if (secondsElasped >= 1)
+                {
+                    kvp.Value.LastWorldPosition = kvp.Value.TargetWorldPosition;
+                    kvp.Value.TargetWorldPosition = null;
+                    kvp.Value.UpdateStart = null;
+                }
+                else
+                {
+                    var lerp = Vector3.Lerp(kvp.Value.LastWorldPosition ?? Vector3.One, kvp.Value.TargetWorldPosition ?? Vector3.One, (float)secondsElasped);
+                    _vfxSpawnManager.MoveObject(kvp.Value.SpawnedVfxId.Value, lerp);
+                }
+            }
+        }
+    }
+
+    private void OnReceiveCharaData(CharaDataDownloadDto charaDataDownloadDto)
+    {
+        if (!_usersInLobby.TryGetValue(charaDataDownloadDto.Uploader.UID, out var lobbyData))
+        {
+            return;
+        }
+
+        lobbyData.CharaData = charaDataDownloadDto;
+        if (lobbyData.Address != nint.Zero && !string.IsNullOrEmpty(lobbyData.AssociatedCharaName))
+        {
+            _ = ApplyCharaData(lobbyData);
+        }
+    }
+
+    public async Task ApplyCharaData(GposeLobbyUserData userData)
+    {
+        if (userData.CharaData == null || userData.Address == nint.Zero || string.IsNullOrEmpty(userData.AssociatedCharaName))
+            return;
+
+        await _charaDataCreationSemaphore.WaitAsync(_lobbyCts.Token).ConfigureAwait(false);
+
+        try
+        {
+            await _charaDataManager.ApplyCharaData(userData.CharaData!, userData.AssociatedCharaName).ConfigureAwait(false);
+            userData.LastAppliedCharaDataDate = userData.CharaData.UpdatedDate;
+            userData.HasPoseDataUpdate = true;
+            userData.HasWorldDataUpdate = true;
+        }
+        finally
+        {
+            _charaDataCreationSemaphore.Release();
+        }
+    }
+
+    private readonly SemaphoreSlim _charaDataSpawnSemaphore = new(1, 1);
+
+    internal async Task SpawnAndApplyData(GposeLobbyUserData userData)
+    {
+        if (userData.CharaData == null)
+            return;
+
+        await _charaDataSpawnSemaphore.WaitAsync(_lobbyCts.Token).ConfigureAwait(false);
+        try
+        {
+            userData.HasPoseDataUpdate = false;
+            userData.HasWorldDataUpdate = false;
+            var chara = await _charaDataManager.SpawnAndApplyData(userData.CharaData).ConfigureAwait(false);
+            if (chara == null) return;
+            userData.HandledChara = chara;
+            userData.AssociatedCharaName = chara.Name;
+            userData.HasPoseDataUpdate = true;
+            userData.HasWorldDataUpdate = true;
+        }
+        finally
+        {
+            _charaDataSpawnSemaphore.Release();
+        }
+    }
+
+    private void OnReceivePoseData(UserData userData, PoseData poseData)
+    {
+        if (!_usersInLobby.TryGetValue(userData.UID, out var lobbyData))
+        {
+            return;
+        }
+
+        if (poseData.IsDelta)
+            lobbyData.DeltaPoseData = poseData;
+        else
+            lobbyData.FullPoseData = poseData;
+    }
+
+    private void OnReceiveWorldData(UserData userData, WorldData worldData)
+    {
+        _usersInLobby[userData.UID].WorldData = worldData;
+        _ = _usersInLobby[userData.UID].SetWorldDataDescriptor(_dalamudUtil);
+    }
+
+    private void OnUserJoinLobby(UserData userData)
+    {
+        if (_usersInLobby.ContainsKey(userData.UID))
+            OnUserLeaveLobby(userData);
+        _usersInLobby[userData.UID] = new(userData);
+        _ = PushCharacterDownloadDto();
+    }
+
+    private void OnUserLeaveLobby(UserData msg)
+    {
+        _usersInLobby.Remove(msg.UID, out var existingData);
+        if (existingData != default)
+        {
+            _ = _dalamudUtil.RunOnFrameworkThread(() => _vfxSpawnManager.DespawnObject(existingData.SpawnedVfxId));
+        }
+    }
+}

MareSynchronos/Services/CharaData/CharaDataNearbyManager.cs

@@ -0,0 +1,296 @@
+using FFXIVClientStructs.FFXIV.Client.Graphics.Scene;
+using MareSynchronos.API.Data;
+using MareSynchronos.Interop;
+using MareSynchronos.MareConfiguration;
+using MareSynchronos.Services.CharaData.Models;
+using MareSynchronos.Services.Mediator;
+using MareSynchronos.Services.ServerConfiguration;
+using Microsoft.Extensions.Logging;
+using System.Numerics;
+
+namespace MareSynchronos.Services;
+
+public sealed class CharaDataNearbyManager : DisposableMediatorSubscriberBase
+{
+    public record NearbyCharaDataEntry
+    {
+        public float Direction { get; init; }
+        public float Distance { get; init; }
+    }
+
+    private readonly DalamudUtilService _dalamudUtilService;
+    private readonly Dictionary<PoseEntryExtended, NearbyCharaDataEntry> _nearbyData = [];
+    private readonly Dictionary<PoseEntryExtended, Guid> _poseVfx = [];
+    private readonly ServerConfigurationManager _serverConfigurationManager;
+    private readonly CharaDataConfigService _charaDataConfigService;
+    private readonly Dictionary<UserData, List<CharaDataMetaInfoExtendedDto>> _metaInfoCache = [];
+    private readonly VfxSpawnManager _vfxSpawnManager;
+    private Task? _filterEntriesRunningTask;
+    private (Guid VfxId, PoseEntryExtended Pose)? _hoveredVfx = null;
+    private DateTime _lastExecutionTime = DateTime.UtcNow;
+    private SemaphoreSlim _sharedDataUpdateSemaphore = new(1, 1);
+    public CharaDataNearbyManager(ILogger<CharaDataNearbyManager> logger, MareMediator mediator,
+        DalamudUtilService dalamudUtilService, VfxSpawnManager vfxSpawnManager,
+        ServerConfigurationManager serverConfigurationManager,
+        CharaDataConfigService charaDataConfigService) : base(logger, mediator)
+    {
+        mediator.Subscribe<FrameworkUpdateMessage>(this, (_) => HandleFrameworkUpdate());
+        mediator.Subscribe<CutsceneFrameworkUpdateMessage>(this, (_) => HandleFrameworkUpdate());
+        _dalamudUtilService = dalamudUtilService;
+        _vfxSpawnManager = vfxSpawnManager;
+        _serverConfigurationManager = serverConfigurationManager;
+        _charaDataConfigService = charaDataConfigService;
+        mediator.Subscribe<GposeStartMessage>(this, (_) => ClearAllVfx());
+    }
+
+    public bool ComputeNearbyData { get; set; } = false;
+
+    public IDictionary<PoseEntryExtended, NearbyCharaDataEntry> NearbyData => _nearbyData;
+
+    public string UserNoteFilter { get; set; } = string.Empty;
+
+    public void UpdateSharedData(Dictionary<string, CharaDataMetaInfoExtendedDto?> newData)
+    {
+        _sharedDataUpdateSemaphore.Wait();
+        try
+        {
+            _metaInfoCache.Clear();
+            foreach (var kvp in newData)
+            {
+                if (kvp.Value == null) continue;
+
+                if (!_metaInfoCache.TryGetValue(kvp.Value.Uploader, out var list))
+                {
+                    _metaInfoCache[kvp.Value.Uploader] = list = [];
+                }
+
+                list.Add(kvp.Value);
+            }
+        }
+        finally
+        {
+            _sharedDataUpdateSemaphore.Release();
+        }
+    }
+
+    internal void SetHoveredVfx(PoseEntryExtended? hoveredPose)
+    {
+        if (hoveredPose == null && _hoveredVfx == null)
+            return;
+
+        if (hoveredPose == null)
+        {
+            _vfxSpawnManager.DespawnObject(_hoveredVfx!.Value.VfxId);
+            _hoveredVfx = null;
+            return;
+        }
+
+        if (_hoveredVfx == null)
+        {
+            var vfxGuid = _vfxSpawnManager.SpawnObject(hoveredPose.Position, hoveredPose.Rotation, Vector3.One * 4, 1, 0.2f, 0.2f, 1f);
+            if (vfxGuid != null)
+                _hoveredVfx = (vfxGuid.Value, hoveredPose);
+            return;
+        }
+
+        if (hoveredPose != _hoveredVfx!.Value.Pose)
+        {
+            _vfxSpawnManager.DespawnObject(_hoveredVfx.Value.VfxId);
+            var vfxGuid = _vfxSpawnManager.SpawnObject(hoveredPose.Position, hoveredPose.Rotation, Vector3.One * 4, 1, 0.2f, 0.2f, 1f);
+            if (vfxGuid != null)
+                _hoveredVfx = (vfxGuid.Value, hoveredPose);
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+        ClearAllVfx();
+    }
+
+    private static float CalculateYawDegrees(Vector3 directionXZ)
+    {
+        // Calculate yaw angle in radians using Atan2 (X, Z)
+        float yawRadians = (float)Math.Atan2(-directionXZ.X, directionXZ.Z);
+        float yawDegrees = yawRadians * (180f / (float)Math.PI);
+
+        // Normalize to [0, 360)
+        if (yawDegrees < 0)
+            yawDegrees += 360f;
+
+        return yawDegrees;
+    }
+
+    private static float GetAngleToTarget(Vector3 cameraPosition, float cameraYawDegrees, Vector3 targetPosition)
+    {
+        // Step 4: Calculate the direction vector from camera to target
+        Vector3 directionToTarget = targetPosition - cameraPosition;
+
+        // Step 5: Project the directionToTarget onto the XZ plane (ignore Y)
+        Vector3 directionToTargetXZ = new Vector3(directionToTarget.X, 0, directionToTarget.Z);
+
+        // Handle the case where the target is directly above or below the camera
+        if (directionToTargetXZ.LengthSquared() < 1e-10f)
+        {
+            return 0; // Default direction
+        }
+
+        directionToTargetXZ = Vector3.Normalize(directionToTargetXZ);
+
+        // Step 6: Calculate the target's yaw angle
+        float targetYawDegrees = CalculateYawDegrees(directionToTargetXZ);
+
+        // Step 7: Calculate relative angle
+        float relativeAngle = targetYawDegrees - cameraYawDegrees;
+        if (relativeAngle < 0)
+            relativeAngle += 360f;
+
+        // Step 8: Map relative angle to ArrowDirection
+        return relativeAngle;
+    }
+
+    private static float GetCameraYaw(Vector3 cameraPosition, Vector3 lookAtVector)
+    {
+        // Step 1: Calculate the direction vector from camera to LookAtPoint
+        Vector3 directionFacing = lookAtVector - cameraPosition;
+
+        // Step 2: Project the directionFacing onto the XZ plane (ignore Y)
+        Vector3 directionFacingXZ = new Vector3(directionFacing.X, 0, directionFacing.Z);
+
+        // Handle the case where the LookAtPoint is directly above or below the camera
+        if (directionFacingXZ.LengthSquared() < 1e-10f)
+        {
+            // Default to facing forward along the Z-axis if LookAtPoint is directly above or below
+            directionFacingXZ = new Vector3(0, 0, 1);
+        }
+        else
+        {
+            directionFacingXZ = Vector3.Normalize(directionFacingXZ);
+        }
+
+        // Step 3: Calculate the camera's yaw angle based on directionFacingXZ
+        return (CalculateYawDegrees(directionFacingXZ));
+    }
+
+    private void ClearAllVfx()
+    {
+        foreach (var vfx in _poseVfx)
+        {
+            _vfxSpawnManager.DespawnObject(vfx.Value);
+        }
+        _poseVfx.Clear();
+    }
+
+    private async Task FilterEntriesAsync(Vector3 cameraPos, Vector3 cameraLookAt)
+    {
+        var previousPoses = _nearbyData.Keys.ToList();
+        _nearbyData.Clear();
+
+        var ownLocation = await _dalamudUtilService.RunOnFrameworkThread(() => _dalamudUtilService.GetMapData()).ConfigureAwait(false);
+        var player = await _dalamudUtilService.RunOnFrameworkThread(() => _dalamudUtilService.GetPlayerCharacter()).ConfigureAwait(false);
+        var currentServer = player.CurrentWorld;
+        var playerPos = player.Position;
+
+        var cameraYaw = GetCameraYaw(cameraPos, cameraLookAt);
+
+        bool ignoreHousingLimits = _charaDataConfigService.Current.NearbyIgnoreHousingLimitations;
+        bool onlyCurrentServer = _charaDataConfigService.Current.NearbyOwnServerOnly;
+        bool showOwnData = _charaDataConfigService.Current.NearbyShowOwnData;
+
+        // initial filter on name
+        foreach (var data in _metaInfoCache.Where(d => (string.IsNullOrWhiteSpace(UserNoteFilter)
+            || ((d.Key.Alias ?? string.Empty).Contains(UserNoteFilter, StringComparison.OrdinalIgnoreCase)
+            || d.Key.UID.Contains(UserNoteFilter, StringComparison.OrdinalIgnoreCase)
+            || (_serverConfigurationManager.GetNoteForUid(UserNoteFilter) ?? string.Empty).Contains(UserNoteFilter, StringComparison.OrdinalIgnoreCase))))
+            .ToDictionary(k => k.Key, k => k.Value))
+        {
+            // filter all poses based on territory, that always must be correct
+            foreach (var pose in data.Value.Where(v => v.HasPoses && v.HasWorldData && (showOwnData || !v.IsOwnData))
+                .SelectMany(k => k.PoseExtended)
+                .Where(p => p.HasPoseData
+                    && p.HasWorldData
+                    && p.WorldData!.Value.LocationInfo.TerritoryId == ownLocation.TerritoryId)
+                .ToList())
+            {
+                var poseLocation = pose.WorldData!.Value.LocationInfo;
+
+                bool isInHousing = poseLocation.WardId != 0;
+                var distance = Vector3.Distance(playerPos, pose.Position);
+                if (distance > _charaDataConfigService.Current.NearbyDistanceFilter) continue;
+
+
+                bool addEntry = (!isInHousing && poseLocation.MapId == ownLocation.MapId
+                        && (!onlyCurrentServer || poseLocation.ServerId == currentServer.RowId))
+                    || (isInHousing
+                        && (((ignoreHousingLimits && !onlyCurrentServer)
+                            || (ignoreHousingLimits && onlyCurrentServer) && poseLocation.ServerId == currentServer.RowId)
+                            || poseLocation.ServerId == currentServer.RowId)
+                        && ((poseLocation.HouseId == 0 && poseLocation.DivisionId == ownLocation.DivisionId
+                                && (ignoreHousingLimits || poseLocation.WardId == ownLocation.WardId))
+                            || (poseLocation.HouseId > 0
+                                && (ignoreHousingLimits || (poseLocation.HouseId == ownLocation.HouseId && poseLocation.WardId == ownLocation.WardId && poseLocation.DivisionId == ownLocation.DivisionId && poseLocation.RoomId == ownLocation.RoomId)))
+                           ));
+
+                if (addEntry)
+                    _nearbyData[pose] = new() { Direction = GetAngleToTarget(cameraPos, cameraYaw, pose.Position), Distance = distance };
+            }
+        }
+
+        if (_charaDataConfigService.Current.NearbyDrawWisps && !_dalamudUtilService.IsInGpose && !_dalamudUtilService.IsInCombatOrPerforming)
+            await _dalamudUtilService.RunOnFrameworkThread(() => ManageWispsNearby(previousPoses)).ConfigureAwait(false);
+    }
+
+    private unsafe void HandleFrameworkUpdate()
+    {
+        if (_lastExecutionTime.AddSeconds(0.5) > DateTime.UtcNow) return;
+        _lastExecutionTime = DateTime.UtcNow;
+        if (!ComputeNearbyData && !_charaDataConfigService.Current.NearbyShowAlways)
+        {
+            if (_nearbyData.Any())
+                _nearbyData.Clear();
+            if (_poseVfx.Any())
+                ClearAllVfx();
+            return;
+        }
+
+        if (!_charaDataConfigService.Current.NearbyDrawWisps || _dalamudUtilService.IsInGpose || _dalamudUtilService.IsInCombatOrPerforming)
+            ClearAllVfx();
+
+        var camera = CameraManager.Instance()->CurrentCamera;
+        Vector3 cameraPos = new(camera->Position.X, camera->Position.Y, camera->Position.Z);
+        Vector3 lookAt = new(camera->LookAtVector.X, camera->LookAtVector.Y, camera->LookAtVector.Z);
+
+        if (_filterEntriesRunningTask?.IsCompleted ?? true && _dalamudUtilService.IsLoggedIn)
+            _filterEntriesRunningTask = FilterEntriesAsync(cameraPos, lookAt);
+    }
+
+    private void ManageWispsNearby(List<PoseEntryExtended> previousPoses)
+    {
+        foreach (var data in _nearbyData.Keys)
+        {
+            if (_poseVfx.TryGetValue(data, out var _)) continue;
+
+            Guid? vfxGuid;
+            if (data.MetaInfo.IsOwnData)
+            {
+                vfxGuid = _vfxSpawnManager.SpawnObject(data.Position, data.Rotation, Vector3.One * 2, 0.8f, 0.5f, 0.0f, 0.7f);
+            }
+            else
+            {
+                vfxGuid = _vfxSpawnManager.SpawnObject(data.Position, data.Rotation, Vector3.One * 2);
+            }
+            if (vfxGuid != null)
+            {
+                _poseVfx[data] = vfxGuid.Value;
+            }
+        }
+
+        foreach (var data in previousPoses.Except(_nearbyData.Keys))
+        {
+            if (_poseVfx.Remove(data, out var guid))
+            {
+                _vfxSpawnManager.DespawnObject(guid);
+            }
+        }
+    }
+}

MareSynchronos/Services/CharaData/MareCharaFileDataFactory.cs

@@ -0,0 +1,20 @@
+using MareSynchronos.API.Data;
+using MareSynchronos.FileCache;
+using MareSynchronos.Services.CharaData.Models;
+
+namespace MareSynchronos.Services.CharaData;
+
+public sealed class MareCharaFileDataFactory
+{
+    private readonly FileCacheManager _fileCacheManager;
+
+    public MareCharaFileDataFactory(FileCacheManager fileCacheManager)
+    {
+        _fileCacheManager = fileCacheManager;
+    }
+
+    public MareCharaFileData Create(string description, CharacterData characterCacheDto)
+    {
+        return new MareCharaFileData(_fileCacheManager, description, characterCacheDto);
+    }
+}

MareSynchronos/Services/CharaData/Models/CharaDataExtendedUpdateDto.cs

@@ -0,0 +1,362 @@
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Dto.CharaData;
+
+namespace MareSynchronos.Services.CharaData.Models;
+
+public sealed record CharaDataExtendedUpdateDto : CharaDataUpdateDto
+{
+    private readonly CharaDataFullDto _charaDataFullDto;
+
+    public CharaDataExtendedUpdateDto(CharaDataUpdateDto dto, CharaDataFullDto charaDataFullDto) : base(dto)
+    {
+        _charaDataFullDto = charaDataFullDto;
+        _userList = charaDataFullDto.AllowedUsers.ToList();
+        _groupList = charaDataFullDto.AllowedGroups.ToList();
+        _poseList = charaDataFullDto.PoseData.Select(k => new PoseEntry(k.Id)
+        {
+            Description = k.Description,
+            PoseData = k.PoseData,
+            WorldData = k.WorldData
+        }).ToList();
+    }
+
+    public CharaDataUpdateDto BaseDto => new(Id)
+    {
+        AllowedUsers = AllowedUsers,
+        AllowedGroups = AllowedGroups,
+        AccessType = base.AccessType,
+        CustomizeData = base.CustomizeData,
+        Description = base.Description,
+        ExpiryDate = base.ExpiryDate,
+        FileGamePaths = base.FileGamePaths,
+        FileSwaps = base.FileSwaps,
+        GlamourerData = base.GlamourerData,
+        ShareType = base.ShareType,
+        ManipulationData = base.ManipulationData,
+        Poses = Poses
+    };
+
+    public new string ManipulationData
+    {
+        get
+        {
+            return base.ManipulationData ?? _charaDataFullDto.ManipulationData;
+        }
+        set
+        {
+            base.ManipulationData = value;
+            if (string.Equals(base.ManipulationData, _charaDataFullDto.ManipulationData, StringComparison.Ordinal))
+            {
+                base.ManipulationData = null;
+            }
+        }
+    }
+
+    public new string Description
+    {
+        get
+        {
+            return base.Description ?? _charaDataFullDto.Description;
+        }
+        set
+        {
+            base.Description = value;
+            if (string.Equals(base.Description, _charaDataFullDto.Description, StringComparison.Ordinal))
+            {
+                base.Description = null;
+            }
+        }
+    }
+
+    public new DateTime ExpiryDate
+    {
+        get
+        {
+            return base.ExpiryDate ?? _charaDataFullDto.ExpiryDate;
+        }
+        private set
+        {
+            base.ExpiryDate = value;
+            if (Equals(base.ExpiryDate, _charaDataFullDto.ExpiryDate))
+            {
+                base.ExpiryDate = null;
+            }
+        }
+    }
+
+    public new AccessTypeDto AccessType
+    {
+        get
+        {
+            return base.AccessType ?? _charaDataFullDto.AccessType;
+        }
+        set
+        {
+            base.AccessType = value;
+            if (AccessType == AccessTypeDto.Public && ShareType == ShareTypeDto.Shared)
+            {
+                ShareType = ShareTypeDto.Private;
+            }
+
+            if (Equals(base.AccessType, _charaDataFullDto.AccessType))
+            {
+                base.AccessType = null;
+            }
+        }
+    }
+
+    public new ShareTypeDto ShareType
+    {
+        get
+        {
+            return base.ShareType ?? _charaDataFullDto.ShareType;
+        }
+        set
+        {
+            base.ShareType = value;
+            if (ShareType == ShareTypeDto.Shared && AccessType == AccessTypeDto.Public)
+            {
+                base.ShareType = ShareTypeDto.Private;
+            }
+
+            if (Equals(base.ShareType, _charaDataFullDto.ShareType))
+            {
+                base.ShareType = null;
+            }
+        }
+    }
+
+    public new List<GamePathEntry>? FileGamePaths
+    {
+        get
+        {
+            return base.FileGamePaths ?? _charaDataFullDto.FileGamePaths;
+        }
+        set
+        {
+            base.FileGamePaths = value;
+            if (!(base.FileGamePaths ?? []).Except(_charaDataFullDto.FileGamePaths).Any()
+                && !_charaDataFullDto.FileGamePaths.Except(base.FileGamePaths ?? []).Any())
+            {
+                base.FileGamePaths = null;
+            }
+        }
+    }
+
+    public new List<GamePathEntry>? FileSwaps
+    {
+        get
+        {
+            return base.FileSwaps ?? _charaDataFullDto.FileSwaps;
+        }
+        set
+        {
+            base.FileSwaps = value;
+            if (!(base.FileSwaps ?? []).Except(_charaDataFullDto.FileSwaps).Any()
+                && !_charaDataFullDto.FileSwaps.Except(base.FileSwaps ?? []).Any())
+            {
+                base.FileSwaps = null;
+            }
+        }
+    }
+
+    public new string? GlamourerData
+    {
+        get
+        {
+            return base.GlamourerData ?? _charaDataFullDto.GlamourerData;
+        }
+        set
+        {
+            base.GlamourerData = value;
+            if (string.Equals(base.GlamourerData, _charaDataFullDto.GlamourerData, StringComparison.Ordinal))
+            {
+                base.GlamourerData = null;
+            }
+        }
+    }
+
+    public new string? CustomizeData
+    {
+        get
+        {
+            return base.CustomizeData ?? _charaDataFullDto.CustomizeData;
+        }
+        set
+        {
+            base.CustomizeData = value;
+            if (string.Equals(base.CustomizeData, _charaDataFullDto.CustomizeData, StringComparison.Ordinal))
+            {
+                base.CustomizeData = null;
+            }
+        }
+    }
+
+    public IEnumerable<UserData> UserList => _userList;
+    private readonly List<UserData> _userList;
+
+    public IEnumerable<GroupData> GroupList => _groupList;
+    private readonly List<GroupData> _groupList;
+
+    public IEnumerable<PoseEntry> PoseList => _poseList;
+    private readonly List<PoseEntry> _poseList;
+
+    public void AddUserToList(string user)
+    {
+        _userList.Add(new(user, null));
+        UpdateAllowedUsers();
+    }
+
+    public void AddGroupToList(string group)
+    {
+        _groupList.Add(new(group, null));
+        UpdateAllowedGroups();
+    }
+
+    private void UpdateAllowedUsers()
+    {
+        AllowedUsers = [.. _userList.Select(u => u.UID)];
+        if (!AllowedUsers.Except(_charaDataFullDto.AllowedUsers.Select(u => u.UID), StringComparer.Ordinal).Any()
+            && !_charaDataFullDto.AllowedUsers.Select(u => u.UID).Except(AllowedUsers, StringComparer.Ordinal).Any())
+        {
+            AllowedUsers = null;
+        }
+    }
+
+    private void UpdateAllowedGroups()
+    {
+        AllowedGroups = [.. _groupList.Select(u => u.GID)];
+        if (!AllowedGroups.Except(_charaDataFullDto.AllowedGroups.Select(u => u.GID), StringComparer.Ordinal).Any()
+            && !_charaDataFullDto.AllowedGroups.Select(u => u.GID).Except(AllowedGroups, StringComparer.Ordinal).Any())
+        {
+            AllowedGroups = null;
+        }
+    }
+
+    public void RemoveUserFromList(string user)
+    {
+        _userList.RemoveAll(u => string.Equals(u.UID, user, StringComparison.Ordinal));
+        UpdateAllowedUsers();
+    }
+
+    public void RemoveGroupFromList(string group)
+    {
+        _groupList.RemoveAll(u => string.Equals(u.GID, group, StringComparison.Ordinal));
+        UpdateAllowedGroups();
+    }
+
+    public void AddPose()
+    {
+        _poseList.Add(new PoseEntry(null));
+        UpdatePoseList();
+    }
+
+    public void RemovePose(PoseEntry entry)
+    {
+        if (entry.Id != null)
+        {
+            entry.Description = null;
+            entry.WorldData = null;
+            entry.PoseData = null;
+        }
+        else
+        {
+            _poseList.Remove(entry);
+        }
+
+        UpdatePoseList();
+    }
+
+    public void UpdatePoseList()
+    {
+        Poses = [.. _poseList];
+        if (!Poses.Except(_charaDataFullDto.PoseData).Any() && !_charaDataFullDto.PoseData.Except(Poses).Any())
+        {
+            Poses = null;
+        }
+    }
+
+    public void SetExpiry(bool expiring)
+    {
+        if (expiring)
+        {
+            var date = DateTime.UtcNow.AddDays(7);
+            SetExpiry(date.Year, date.Month, date.Day);
+        }
+        else
+        {
+            ExpiryDate = DateTime.MaxValue;
+        }
+    }
+
+    public void SetExpiry(int year, int month, int day)
+    {
+        int daysInMonth = DateTime.DaysInMonth(year, month);
+        if (day > daysInMonth) day = 1;
+        ExpiryDate = new DateTime(year, month, day, 0, 0, 0, DateTimeKind.Utc);
+    }
+
+    internal void UndoChanges()
+    {
+        base.Description = null;
+        base.AccessType = null;
+        base.ShareType = null;
+        base.GlamourerData = null;
+        base.FileSwaps = null;
+        base.FileGamePaths = null;
+        base.CustomizeData = null;
+        base.ManipulationData = null;
+        AllowedUsers = null;
+        AllowedGroups = null;
+        Poses = null;
+        _poseList.Clear();
+        _poseList.AddRange(_charaDataFullDto.PoseData.Select(k => new PoseEntry(k.Id)
+        {
+            Description = k.Description,
+            PoseData = k.PoseData,
+            WorldData = k.WorldData
+        }));
+    }
+
+    internal void RevertDeletion(PoseEntry pose)
+    {
+        if (pose.Id == null) return;
+        var oldPose = _charaDataFullDto.PoseData.Find(p => p.Id == pose.Id);
+        if (oldPose == null) return;
+        pose.Description = oldPose.Description;
+        pose.PoseData = oldPose.PoseData;
+        pose.WorldData = oldPose.WorldData;
+        UpdatePoseList();
+    }
+
+    internal bool PoseHasChanges(PoseEntry pose)
+    {
+        if (pose.Id == null) return false;
+        var oldPose = _charaDataFullDto.PoseData.Find(p => p.Id == pose.Id);
+        if (oldPose == null) return false;
+        return !string.Equals(pose.Description, oldPose.Description, StringComparison.Ordinal)
+            || !string.Equals(pose.PoseData, oldPose.PoseData, StringComparison.Ordinal)
+            || pose.WorldData != oldPose.WorldData;
+    }
+
+    public bool HasChanges =>
+                base.Description != null
+                || base.ExpiryDate != null
+                || base.AccessType != null
+                || base.ShareType != null
+                || AllowedUsers != null
+                || AllowedGroups != null
+                || base.GlamourerData != null
+                || base.FileSwaps != null
+                || base.FileGamePaths != null
+                || base.CustomizeData != null
+                || base.ManipulationData != null
+                || Poses != null;
+
+    public bool IsAppearanceEqual =>
+        string.Equals(GlamourerData, _charaDataFullDto.GlamourerData, StringComparison.Ordinal)
+        && string.Equals(CustomizeData, _charaDataFullDto.CustomizeData, StringComparison.Ordinal)
+        && FileGamePaths == _charaDataFullDto.FileGamePaths
+        && FileSwaps == _charaDataFullDto.FileSwaps
+        && string.Equals(ManipulationData, _charaDataFullDto.ManipulationData, StringComparison.Ordinal);
+}

MareSynchronos/Services/CharaData/Models/CharaDataFullExtendedDto.cs

@@ -0,0 +1,18 @@
+using MareSynchronos.API.Dto.CharaData;
+using System.Collections.ObjectModel;
+
+namespace MareSynchronos.Services.CharaData.Models;
+
+public sealed record CharaDataFullExtendedDto : CharaDataFullDto
+{
+    public CharaDataFullExtendedDto(CharaDataFullDto baseDto) : base(baseDto)
+    {
+        FullId = baseDto.Uploader.UID + ":" + baseDto.Id;
+        MissingFiles = new ReadOnlyCollection<GamePathEntry>(baseDto.OriginalFiles.Except(baseDto.FileGamePaths).ToList());
+        HasMissingFiles = MissingFiles.Any();
+    }
+
+    public string FullId { get; set; }
+    public bool HasMissingFiles { get; init; }
+    public IReadOnlyCollection<GamePathEntry> MissingFiles { get; init; }
+}

MareSynchronos/Services/CharaData/Models/CharaDataMetaInfoExtendedDto.cs

@@ -0,0 +1,31 @@
+using MareSynchronos.API.Dto.CharaData;
+
+namespace MareSynchronos.Services.CharaData.Models;
+
+public sealed record CharaDataMetaInfoExtendedDto : CharaDataMetaInfoDto
+{
+    private CharaDataMetaInfoExtendedDto(CharaDataMetaInfoDto baseMeta) : base(baseMeta)
+    {
+        FullId = baseMeta.Uploader.UID + ":" + baseMeta.Id;
+    }
+
+    public List<PoseEntryExtended> PoseExtended { get; private set; } = [];
+    public bool HasPoses => PoseExtended.Count != 0;
+    public bool HasWorldData => PoseExtended.Exists(p => p.HasWorldData);
+    public bool IsOwnData { get; private set; }
+    public string FullId { get; private set; }
+
+    public async static Task<CharaDataMetaInfoExtendedDto> Create(CharaDataMetaInfoDto baseMeta, DalamudUtilService dalamudUtilService, bool isOwnData = false)
+    {
+        CharaDataMetaInfoExtendedDto newDto = new(baseMeta);
+
+        foreach (var pose in newDto.PoseData)
+        {
+            newDto.PoseExtended.Add(await PoseEntryExtended.Create(pose, newDto, dalamudUtilService).ConfigureAwait(false));
+        }
+
+        newDto.IsOwnData = isOwnData;
+
+        return newDto;
+    }
+}

MareSynchronos/Services/CharaData/Models/GposeLobbyUserData.cs

@@ -0,0 +1,174 @@
+using Dalamud.Utility;
+using MareSynchronos.API.Data;
+using MareSynchronos.API.Dto.CharaData;
+using MareSynchronos.Utils;
+using System.Globalization;
+using System.Numerics;
+using System.Text;
+
+namespace MareSynchronos.Services.CharaData.Models;
+
+public sealed record GposeLobbyUserData(UserData UserData)
+{
+    public void Reset()
+    {
+        HasWorldDataUpdate = WorldData != null;
+        HasPoseDataUpdate = ApplicablePoseData != null;
+        SpawnedVfxId = null;
+        LastAppliedCharaDataDate = DateTime.MinValue;
+    }
+
+    private WorldData? _worldData;
+    public WorldData? WorldData
+    {
+        get => _worldData; set
+        {
+            _worldData = value;
+            HasWorldDataUpdate = true;
+        }
+    }
+
+    public bool HasWorldDataUpdate { get; set; } = false;
+
+    private PoseData? _fullPoseData;
+    private PoseData? _deltaPoseData;
+
+    public PoseData? FullPoseData
+    {
+        get => _fullPoseData;
+        set
+        {
+            _fullPoseData = value;
+            ApplicablePoseData = CombinePoseData();
+            HasPoseDataUpdate = true;
+        }
+    }
+
+    public PoseData? DeltaPoseData
+    {
+        get => _deltaPoseData;
+        set
+        {
+            _deltaPoseData = value;
+            ApplicablePoseData = CombinePoseData();
+            HasPoseDataUpdate = true;
+        }
+    }
+
+    public PoseData? ApplicablePoseData { get; private set; }
+    public bool HasPoseDataUpdate { get; set; } = false;
+    public Guid? SpawnedVfxId { get; set; }
+    public Vector3? LastWorldPosition { get; set; }
+    public Vector3? TargetWorldPosition { get; set; }
+    public DateTime? UpdateStart { get; set; }
+    private CharaDataDownloadDto? _charaData;
+    public CharaDataDownloadDto? CharaData
+    {
+        get => _charaData; set
+        {
+            _charaData = value;
+            LastUpdatedCharaData = _charaData?.UpdatedDate ?? DateTime.MaxValue;
+        }
+    }
+
+    public DateTime LastUpdatedCharaData { get; private set; } = DateTime.MaxValue;
+    public DateTime LastAppliedCharaDataDate { get; set; } = DateTime.MinValue;
+    public nint Address { get; set; }
+    public string AssociatedCharaName { get; set; } = string.Empty;
+
+    private PoseData? CombinePoseData()
+    {
+        if (DeltaPoseData == null && FullPoseData != null) return FullPoseData;
+        if (FullPoseData == null) return null;
+
+        PoseData output = FullPoseData!.Value.DeepClone();
+        PoseData delta = DeltaPoseData!.Value;
+
+        foreach (var bone in FullPoseData!.Value.Bones)
+        {
+            if (!delta.Bones.TryGetValue(bone.Key, out var data)) continue;
+            if (!data.Exists)
+            {
+                output.Bones.Remove(bone.Key);
+            }
+            else
+            {
+                output.Bones[bone.Key] = data;
+            }
+        }
+
+        foreach (var bone in FullPoseData!.Value.MainHand)
+        {
+            if (!delta.MainHand.TryGetValue(bone.Key, out var data)) continue;
+            if (!data.Exists)
+            {
+                output.MainHand.Remove(bone.Key);
+            }
+            else
+            {
+                output.MainHand[bone.Key] = data;
+            }
+        }
+
+        foreach (var bone in FullPoseData!.Value.OffHand)
+        {
+            if (!delta.OffHand.TryGetValue(bone.Key, out var data)) continue;
+            if (!data.Exists)
+            {
+                output.OffHand.Remove(bone.Key);
+            }
+            else
+            {
+                output.OffHand[bone.Key] = data;
+            }
+        }
+
+        return output;
+    }
+
+    public string WorldDataDescriptor { get; private set; } = string.Empty;
+    public Vector2 MapCoordinates { get; private set; }
+    public Lumina.Excel.Sheets.Map Map { get; private set; }
+    public HandledCharaDataEntry? HandledChara { get; set; }
+
+    public async Task SetWorldDataDescriptor(DalamudUtilService dalamudUtilService)
+    {
+        if (WorldData == null)
+        {
+            WorldDataDescriptor = "No World Data found";
+        }
+
+        var worldData = WorldData!.Value;
+        MapCoordinates = await dalamudUtilService.RunOnFrameworkThread(() =>
+                MapUtil.WorldToMap(new Vector2(worldData.PositionX, worldData.PositionY), dalamudUtilService.MapData.Value[worldData.LocationInfo.MapId].Map))
+            .ConfigureAwait(false);
+        Map = dalamudUtilService.MapData.Value[worldData.LocationInfo.MapId].Map;
+
+        StringBuilder sb = new();
+        sb.AppendLine("Server: " + dalamudUtilService.WorldData.Value[(ushort)worldData.LocationInfo.ServerId]);
+        sb.AppendLine("Territory: " + dalamudUtilService.TerritoryData.Value[worldData.LocationInfo.TerritoryId]);
+        sb.AppendLine("Map: " + dalamudUtilService.MapData.Value[worldData.LocationInfo.MapId].MapName);
+
+        if (worldData.LocationInfo.WardId != 0)
+            sb.AppendLine("Ward #: " + worldData.LocationInfo.WardId);
+        if (worldData.LocationInfo.DivisionId != 0)
+        {
+            sb.AppendLine("Subdivision: " + worldData.LocationInfo.DivisionId switch
+            {
+                1 => "No",
+                2 => "Yes",
+                _ => "-"
+            });
+        }
+        if (worldData.LocationInfo.HouseId != 0)
+        {
+            sb.AppendLine("House #: " + (worldData.LocationInfo.HouseId == 100 ? "Apartments" : worldData.LocationInfo.HouseId.ToString()));
+        }
+        if (worldData.LocationInfo.RoomId != 0)
+        {
+            sb.AppendLine("Apartment #: " + worldData.LocationInfo.RoomId);
+        }
+        sb.AppendLine("Coordinates: X: " + MapCoordinates.X.ToString("0.0", CultureInfo.InvariantCulture) + ", Y: " + MapCoordinates.Y.ToString("0.0", CultureInfo.InvariantCulture));
+        WorldDataDescriptor = sb.ToString();
+    }
+}