Bump plugin testing

Reviewed-on: #138

.gitea/workflows/lightless-tag-and-release.yml

@@ -0,0 +1,268 @@
+name: Tag and Release Lightless
+
+on:
+  push:
+    branches: [ master, dev ]
+
+env:
+  PLUGIN_NAME: LightlessSync
+  DOTNET_VERSION: |
+      10.x.x
+      9.x.x
+  DOTNET_CLI_TELEMETRY_OPTOUT: true
+  
+jobs:
+  tag-and-release:
+    runs-on: ubuntu-22.04
+    permissions:
+      contents: write
+
+    steps:
+    - name: Checkout Lightless
+      uses: actions/checkout@v5
+      with:
+        fetch-depth: 0
+        submodules: recursive
+
+    - name: Setup .NET 10 SDK
+      uses: actions/setup-dotnet@v5
+      with:
+        dotnet-version: |
+          10.x.x
+          9.x.x
+
+    - name: Download Dalamud
+      run: |
+        mkdir -p ~/.xlcore/dalamud/Hooks/dev
+        curl -O https://goatcorp.github.io/dalamud-distrib/stg/latest.zip
+        unzip latest.zip -d ~/.xlcore/dalamud/Hooks/dev
+
+    - name: Lets Build Lightless!
+      run: | 
+        dotnet publish --configuration Release
+        mv LightlessSync/bin/x64/Release/LightlessSync/latest.zip LightlessClient.zip
+
+    - name: Get version
+      id: package_version
+      run: |
+        version=$(grep -oPm1 "(?<=<Version>)[^<]+" LightlessSync/LightlessSync.csproj)
+        echo "version=$version" >> $GITHUB_OUTPUT
+
+    - name: Display version
+      run: | 
+          echo "Version: ${{ steps.package_version.outputs.version }}"
+
+    - name: Create Git tag if not exists (master)
+      if: github.ref == 'refs/heads/master'
+      run: |
+        tag="${{ steps.package_version.outputs.version }}"
+        git fetch --tags
+        if ! git tag -l "$tag" | grep -q "$tag"; then
+          echo "Tag $tag does not exist. Creating and pushing..."
+          git config user.name "GitHub Action"
+          git config user.email "action@github.com"
+          git tag "$tag"
+          git push origin "$tag"
+        else
+          echo "Tag $tag already exists. Skipping tag creation."
+        fi
+
+    - name: Create Git tag if not exists (dev)
+      if: github.ref == 'refs/heads/dev'
+      run: |
+        tag="${{ steps.package_version.outputs.version }}-Dev"
+        git fetch --tags
+        if ! git tag -l "$tag" | grep -q "$tag"; then
+          echo "Tag $tag does not exist. Creating and pushing..."
+          git config user.name "GitHub Action"
+          git config user.email "action@github.com"
+          git tag "$tag"
+          git push origin "$tag"
+        else
+          echo "Tag $tag already exists. Skipping tag creation."
+        fi
+
+    - name: Create Release (master)
+      if: github.ref == 'refs/heads/master'
+      id: create_release
+      run: |
+          echo "=== Searching for existing release ${{ steps.package_version.outputs.version }}==="
+
+          release_id=$(curl -s -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            "https://git.lightless-sync.org/api/v1/repos/${GITHUB_REPOSITORY}/releases/tags/${{ steps.package_version.outputs.version }}" | jq -r .id)
+
+          if [ "$release_id" != "null" ]; then
+            echo "=== Deleting existing release ${{ steps.package_version.outputs.version }}==="
+            curl -X DELETE -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+              "https://git.lightless-sync.org/api/v1/repos/${GITHUB_REPOSITORY}/releases/$release_id"
+          fi
+
+          echo "=== Creating new release ${{ steps.package_version.outputs.version }}==="
+          response=$(
+            curl --fail-with-body -X POST \
+            -H "Content-Type: application/json" \
+            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            -d '{
+              "tag_name": "${{ steps.package_version.outputs.version }}",
+              "name": "${{ steps.package_version.outputs.version }}",
+              "draft": false,
+              "prerelease": false
+            }' \
+           "https://git.lightless-sync.org/api/v1/repos/${GITHUB_REPOSITORY}/releases"
+            )
+
+          echo "API response: $response"
+          release_id=$(echo "$response" | jq -r .id)
+          echo "release_id=$release_id"
+          echo "release_id=$release_id" >> $GITHUB_OUTPUT || echo "::set-output name=release_id::$release_id"
+          echo "RELEASE_ID=$release_id" >> $GITHUB_ENV
+
+    - name: Create Release (dev)
+      if: github.ref == 'refs/heads/dev'
+      id: create_release
+      run: |
+        version="${{ steps.package_version.outputs.version }}-Dev"
+        echo "=== Searching for existing release $version==="
+        release_id=$(curl -s -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+          "https://git.lightless-sync.org/api/v1/repos/${GITHUB_REPOSITORY}/releases/tags/$version" | jq -r .id)
+        if [ "$release_id" != "null" ]; then
+          echo "=== Deleting existing release $version==="
+          curl -X DELETE -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            "https://git.lightless-sync.org/api/v1/repos/${GITHUB_REPOSITORY}/releases/$release_id"
+        fi
+        echo "=== Creating new release $version==="
+        response=$(
+          curl --fail-with-body -X POST \
+          -H "Content-Type: application/json" \
+          -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+          -d '{
+            "tag_name": "'"$version"'",
+            "name": "'"$version"'",
+            "draft": false,
+            "prerelease": false
+          }' \
+         "https://git.lightless-sync.org/api/v1/repos/${GITHUB_REPOSITORY}/releases"
+        )
+        echo "API response: $response"
+        release_id=$(echo "$response" | jq -r .id)
+        echo "release_id=$release_id"
+        echo "release_id=$release_id" >> $GITHUB_OUTPUT || echo "::set-output name=release_id::$release_id"
+        echo "RELEASE_ID=$release_id" >> $GITHUB_ENV
+
+    - name: Upload Assets to release
+      env:
+         RELEASE_ID: ${{ env.RELEASE_ID }}
+      run: |
+          echo "Uploading to release ID: $RELEASE_ID"
+          curl --fail-with-body -s -X POST \
+            -H "Authorization: token ${{ secrets.GITEA_TOKEN }}" \
+            -F "attachment=@LightlessClient.zip" \
+           "https://git.lightless-sync.org/api/v1/repos/${GITHUB_REPOSITORY}/releases/$RELEASE_ID/assets"
+
+    - name: Clone plugin hosting repo
+      run: |
+          mkdir LightlessSyncRepo
+          cd LightlessSyncRepo
+          git clone https://git.lightless-sync.org/${{ gitea.repository_owner }}/LightlessSync.git
+      env:
+          GIT_TERMINAL_PROMPT: 0
+
+    - name: Update plogonmaster.json with version (master)
+      if: github.ref == 'refs/heads/master'
+      env:
+          VERSION: ${{ steps.package_version.outputs.version }}
+      run: |
+            set -e
+
+            pluginJsonPath="${PLUGIN_NAME}/bin/x64/Release/${PLUGIN_NAME}.json"
+            repoJsonPath="LightlessSyncRepo/LightlessSync/plogonmaster.json"
+            version="${VERSION}"
+            downloadUrl="https://git.lightless-sync.org/${{ gitea.repository_owner }}/LightlessClient/releases/download/$version/LightlessClient.zip"
+
+            # Read plugin JSON
+            pluginJson=$(cat "$pluginJsonPath")
+            internalName=$(jq -r '.InternalName' <<< "$pluginJson")
+            dalamudApiLevel=$(jq -r '.DalamudApiLevel' <<< "$pluginJson")
+
+            # Read repo JSON (force array if not already)
+            repoJsonRaw=$(cat "$repoJsonPath")
+            if echo "$repoJsonRaw" | jq 'type' | grep -q '"array"'; then
+              repoJson="$repoJsonRaw"
+            else
+              repoJson="[$repoJsonRaw]"
+            fi
+
+            # Update matching plugin entry
+            updatedRepoJson=$(jq \
+              --arg internalName "$internalName" \
+              --arg dalamudApiLevel "$dalamudApiLevel" \
+              --arg version "$version" \
+              --arg downloadUrl "$downloadUrl" \
+              '
+              map(
+                if .InternalName == $internalName
+                then
+                  .DalamudApiLevel = $dalamudApiLevel
+                  | .AssemblyVersion = $version
+                  | .DownloadLinkInstall = $downloadUrl
+                  | .DownloadLinkUpdate = $downloadUrl
+                else
+                  .
+                end
+              )
+              ' <<< "$repoJson")
+
+            # Write back to file
+            echo "$updatedRepoJson" > "$repoJsonPath"
+            # Output the content of the file
+            cat "$repoJsonPath"
+
+    - name: Update plogonmaster.json with version (dev)
+      if: github.ref == 'refs/heads/dev'
+      env:
+        VERSION: ${{ steps.package_version.outputs.version }}
+      run: |
+        set -e
+        pluginJsonPath="${PLUGIN_NAME}/bin/x64/Release/${PLUGIN_NAME}.json"
+        repoJsonPath="LightlessSyncRepo/LightlessSync/plogonmaster.json"
+        assemblyVersion="${VERSION}"
+        version="${VERSION}-Dev"
+        downloadUrl="https://git.lightless-sync.org/${{ gitea.repository_owner }}/LightlessClient/releases/download/$version/LightlessClient.zip"
+        pluginJson=$(cat "$pluginJsonPath")
+        internalName=$(jq -r '.InternalName' <<< "$pluginJson")
+        dalamudApiLevel=$(jq -r '.DalamudApiLevel' <<< "$pluginJson")
+        repoJsonRaw=$(cat "$repoJsonPath")
+        if echo "$repoJsonRaw" | jq 'type' | grep -q '"array"'; then
+          repoJson="$repoJsonRaw"
+        else
+          repoJson="[$repoJsonRaw]"
+        fi
+        updatedRepoJson=$(jq \
+          --arg internalName "$internalName" \
+          --arg dalamudApiLevel "$dalamudApiLevel" \
+          --arg assemblyVersion "$assemblyVersion" \
+          --arg version "$version" \
+          --arg downloadUrl "$downloadUrl" \
+          '
+          map(
+            if .InternalName == $internalName
+            then
+              .DalamudApiLevel = $dalamudApiLevel
+              | .TestingAssemblyVersion = $assemblyVersion
+              | .DownloadLinkTesting = $downloadUrl
+            else
+              .
+            end
+          )
+          ' <<< "$repoJson")
+        echo "$updatedRepoJson" > "$repoJsonPath"
+        cat "$repoJsonPath"
+
+    - name: Commit and push to LightlessSync
+      run: |
+          cd LightlessSyncRepo/LightlessSync
+          git config user.name "Gitea-Automation"
+          git config user.email "aaa@aaaaaaa.aaa"
+          git add .
+          git diff-index --quiet HEAD || git commit -m "Update ${{ env.PLUGIN_NAME }} to ${{ steps.package_version.outputs.version }}"
+          git push https://x-access-token:${{ secrets.AUTOMATION_TOKEN }}@git.lightless-sync.org/${{ gitea.repository_owner }}/LightlessSync.git HEAD:main

.gitignore

@@ -348,3 +348,6 @@ MigrationBackup/
 
 # Ionide (cross platform F# VS Code tools) working folder
 .ionide/
+
+# idea
+/.idea

.gitmodules

@@ -1,3 +1,18 @@
 [submodule "LightlessAPI"]
 	path = LightlessAPI
-	url = https://github.com/Light-Public-Syncshells/LightlessAPI
+	url = https://git.lightless-sync.org/Lightless-Sync/LightlessAPI.git
+[submodule "Penumbra.GameData"]
+	path = Penumbra.GameData
+	url = https://github.com/Ottermandias/Penumbra.GameData
+[submodule "Penumbra.Api"]
+	path = Penumbra.Api
+	url = https://github.com/Ottermandias/Penumbra.Api
+[submodule "Penumbra.String"]
+	path = Penumbra.String
+	url = https://github.com/Ottermandias/Penumbra.String
+[submodule "OtterGui"]
+	path = OtterGui
+	url = https://github.com/Ottermandias/OtterGui
+[submodule "ffxiv_pictomancy"]
+	path = ffxiv_pictomancy
+	url = https://github.com/sourpuh/ffxiv_pictomancy

LightlessCompactor/FileCache/CompactorInterfaces.cs

@@ -0,0 +1,18 @@
+namespace LightlessSync.FileCache;
+
+public interface ICompactorContext
+{
+    bool UseCompactor { get; }
+    string CacheFolder { get; }
+    bool IsWine { get; }
+}
+
+public interface ICompactionExecutor
+{
+    bool TryCompact(string filePath);
+}
+
+public sealed class NoopCompactionExecutor : ICompactionExecutor
+{
+    public bool TryCompact(string filePath) => false;
+}

LightlessCompactor/LightlessCompactor.csproj

@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.1" />
+  </ItemGroup>
+
+</Project>

LightlessCompactor/Services/Compactor/BatchFileFragService.cs

@@ -0,0 +1,224 @@
+using Microsoft.Extensions.Logging;
+using System.Text.RegularExpressions;
+using System.Threading.Channels;
+
+namespace LightlessSync.Services.Compactor
+{
+    /// <summary>
+    /// This batch service is made for the File Frag command, because of each file needing to use this command.
+    /// It's better to combine into one big command in batches then doing each command on each compressed call.
+    /// </summary>
+    public sealed partial class BatchFilefragService : IDisposable
+    {
+        private readonly Channel<(string path, TaskCompletionSource<bool> tcs)> _ch;
+        private readonly Task _worker;
+        private readonly bool _useShell;
+        private readonly ILogger _log;
+        private readonly int _batchSize;
+        private readonly TimeSpan _flushDelay;
+        private readonly CancellationTokenSource _cts = new();
+
+        public delegate (bool ok, string stdout, string stderr, int exitCode) RunDirect(string fileName, IEnumerable<string> args, string? workingDir, int timeoutMs);
+        private readonly RunDirect _runDirect;
+
+        public delegate (bool ok, string stdout, string stderr, int exitCode) RunShell(string command, string? workingDir, int timeoutMs);
+        private readonly RunShell _runShell;
+
+        public BatchFilefragService(bool useShell, ILogger log, int batchSize = 128, int flushMs = 25, RunDirect? runDirect = null, RunShell? runShell = null)
+        {
+            _useShell = useShell;
+            _log = log;
+            _batchSize = Math.Max(8, batchSize);
+            _flushDelay = TimeSpan.FromMilliseconds(Math.Max(5, flushMs));
+            _ch = Channel.CreateUnbounded<(string, TaskCompletionSource<bool>)>(new UnboundedChannelOptions { SingleReader = true, SingleWriter = false });
+
+            // require runners to be setup, wouldnt start otherwise
+            if (runDirect is null || runShell is null)
+                throw new ArgumentNullException(nameof(runDirect), "Provide process runners from FileCompactor");
+            _runDirect = runDirect;
+            _runShell = runShell;
+
+            _worker = Task.Run(ProcessAsync, _cts.Token);
+        }
+
+        /// <summary>
+        /// Checks if the file is compressed using Btrfs using tasks
+        /// </summary>
+        /// <param name="linuxPath">Linux/Wine path given for the file.</param>
+        /// <param name="ct">Cancellation Token</param>
+        /// <returns>If it was compressed or not</returns>
+        public Task<bool> IsCompressedAsync(string linuxPath, CancellationToken ct = default)
+        {
+            var tcs = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
+
+            if (!_ch.Writer.TryWrite((linuxPath, tcs)))
+            {
+                tcs.TrySetResult(false);
+                return tcs.Task;
+            }
+
+            if (ct.CanBeCanceled)
+            {
+                var reg = ct.Register(() => tcs.TrySetCanceled(ct));
+                _ = tcs.Task.ContinueWith(_ => reg.Dispose(), CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
+            }
+
+            return tcs.Task;
+        }
+
+        /// <summary>
+        /// Process the pending compression tasks asynchronously
+        /// </summary>
+        /// <returns>Task</returns>
+        private async Task ProcessAsync()
+        {
+            var reader = _ch.Reader;
+            var pending = new List<(string path, TaskCompletionSource<bool> tcs)>(_batchSize);
+
+            try
+            {
+                while (await reader.WaitToReadAsync(_cts.Token).ConfigureAwait(false))
+                {
+                    if (!reader.TryRead(out var first)) continue;
+                    pending.Add(first);
+
+                    var flushAt = DateTime.UtcNow + _flushDelay;
+                    while (pending.Count < _batchSize && DateTime.UtcNow < flushAt)
+                    {
+                        if (reader.TryRead(out var item))
+                        {
+                            pending.Add(item);
+                            continue;
+                        }
+
+                        if ((flushAt - DateTime.UtcNow) <= TimeSpan.Zero) break;
+                        try
+                        {
+                            await Task.Delay(TimeSpan.FromMilliseconds(5), _cts.Token).ConfigureAwait(false);
+                        }
+                        catch
+                        {
+                            break;
+                        }
+                    }
+
+                    try
+                    {
+                        var map = RunBatch(pending.Select(p => p.path));
+                        foreach (var (path, tcs) in pending)
+                        {
+                            tcs.TrySetResult(map.TryGetValue(path, out var c) && c);
+                        }
+                    }
+                    catch (Exception ex)
+                    {
+                        _log.LogDebug(ex, "filefrag batch failed. falling back to false");
+                        foreach (var (_, tcs) in pending)
+                        {
+                            tcs.TrySetResult(false);
+                        }
+                    }
+                    finally
+                    {
+                        pending.Clear();
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                //Shutting down worker, exception called
+            }
+        }
+
+        /// <summary>
+        /// Running the batch of each file in the queue in one file frag command.
+        /// </summary>
+        /// <param name="paths">Paths that are needed for the command building for the batch return</param>
+        /// <returns>Path of the file and if it went correctly</returns>
+        /// <exception cref="InvalidOperationException">Failing to start filefrag on the system if this exception is found</exception>
+        private Dictionary<string, bool> RunBatch(IEnumerable<string> paths)
+        {
+            var list = paths.Distinct(StringComparer.Ordinal).ToList();
+            var result = list.ToDictionary(p => p, _ => false, StringComparer.Ordinal);
+
+            (bool ok, string stdout, string stderr, int code) res;
+
+            if (_useShell)
+            {
+                var inner = "filefrag -v -- " + string.Join(' ', list.Select(QuoteSingle));
+                res = _runShell(inner, timeoutMs: 15000, workingDir: "/");
+            }
+            else
+            {
+                var args = new List<string> { "-v", "--" };
+                args.AddRange(list);
+                res = _runDirect("filefrag", args, workingDir: "/", timeoutMs: 15000);
+            }
+
+            if (!string.IsNullOrWhiteSpace(res.stderr))
+                _log.LogTrace("filefrag stderr (batch): {err}", res.stderr.Trim());
+
+            ParseFilefrag(res.stdout, result);
+            return result;
+        }
+
+        /// <summary>
+        /// Parsing the string given from the File Frag command into mapping
+        /// </summary>
+        /// <param name="output">Output of the process from the File Frag</param>
+        /// <param name="map">Mapping of the processed files</param>
+        private static void ParseFilefrag(string output, Dictionary<string, bool> map)
+        {
+            var reHeaderColon = ColonRegex();
+            var reHeaderSize = SizeRegex();
+
+            string? current = null;
+            using var sr = new StringReader(output);
+            for (string? line = sr.ReadLine(); line != null; line = sr.ReadLine())
+            {
+                var m1 = reHeaderColon.Match(line);
+                if (m1.Success) { current = m1.Groups[1].Value; continue; }
+
+                var m2 = reHeaderSize.Match(line);
+                if (m2.Success) { current = m2.Groups[1].Value; continue; }
+
+                if (current is not null && line.Contains("flags:", StringComparison.OrdinalIgnoreCase) &&
+                    line.Contains("compressed", StringComparison.OrdinalIgnoreCase) && map.ContainsKey(current))
+                {
+                    map[current] = true;
+                }
+            }
+        }
+
+        private static string QuoteSingle(string s) => "'" + s.Replace("'", "'\\''", StringComparison.Ordinal) + "'";
+
+        /// <summary>
+        /// Regex of the File Size return on the Linux/Wine systems, giving back the amount
+        /// </summary>
+        /// <returns>Regex of the File Size</returns>
+        [GeneratedRegex(@"^File size of (/.+?) is ", RegexOptions.ExplicitCapture | RegexOptions.CultureInvariant, matchTimeoutMilliseconds: 500)]
+        private static partial Regex SizeRegex();
+
+        /// <summary>
+        /// Regex on colons return on the Linux/Wine systems
+        /// </summary>
+        /// <returns>Regex of the colons in the given path</returns>
+        [GeneratedRegex(@"^(/.+?):\s", RegexOptions.ExplicitCapture | RegexOptions.CultureInvariant, matchTimeoutMilliseconds: 500)]
+        private static partial Regex ColonRegex();
+
+        public void Dispose()
+        {
+            _ch.Writer.TryComplete();
+            _cts.Cancel();
+            try
+            {
+                _worker.Wait(TimeSpan.FromSeconds(2), _cts.Token);
+            }
+            catch
+            {
+                // Ignore the catch in dispose
+            }
+            _cts.Dispose();
+        }
+    }
+}

LightlessCompactor/Utils/FileSystemHelper.cs

@@ -0,0 +1,251 @@
+using Microsoft.Extensions.Logging;
+using System.Collections.Concurrent;
+using System.Runtime.InteropServices;
+
+namespace LightlessSync.Utils
+{
+    public static class FileSystemHelper
+    {
+        public enum FilesystemType
+        {
+            Unknown = 0,
+            NTFS, // Compressable on file level
+            Btrfs, // Compressable on file level
+            Ext4, // Uncompressable
+            Xfs, // Uncompressable
+            Apfs, // Compressable on OS
+            HfsPlus, // Compressable on OS
+            Fat, // Uncompressable
+            Exfat, // Uncompressable
+            Zfs // Compressable, not on file level
+        }
+
+        private const string _mountPath = "/proc/mounts";
+        private const int _defaultBlockSize = 4096;
+        private static readonly Dictionary<string, int> _blockSizeCache = new(StringComparer.OrdinalIgnoreCase);
+        private static readonly ConcurrentDictionary<string, FilesystemType> _filesystemTypeCache = new(StringComparer.OrdinalIgnoreCase);
+
+        public static FilesystemType GetFilesystemType(string filePath, bool isWine = false)
+        {
+            try
+            {
+                string rootPath;
+
+                if (OperatingSystem.IsWindows() && (!IsProbablyWine() || !isWine))
+                {
+                    var info = new FileInfo(filePath);
+                    var dir = info.Directory ?? new DirectoryInfo(filePath);
+                    rootPath = dir.Root.FullName;
+                }
+                else
+                {
+                    rootPath = GetMountPoint(filePath);
+                    if (string.IsNullOrEmpty(rootPath))
+                        rootPath = "/";
+                }
+
+                if (_filesystemTypeCache.TryGetValue(rootPath, out var cachedType))
+                    return cachedType;
+
+                FilesystemType detected;
+
+                if (OperatingSystem.IsWindows() && (!IsProbablyWine() || !isWine))
+                {
+                    var root = new DriveInfo(rootPath);
+                    var format = root.DriveFormat?.ToUpperInvariant() ?? string.Empty;
+
+                    detected = format switch
+                    {
+                        "NTFS" => FilesystemType.NTFS,
+                        "FAT32" => FilesystemType.Fat,
+                        "EXFAT" => FilesystemType.Exfat,
+                        _ => FilesystemType.Unknown
+                    };
+                }
+                else
+                {
+                    detected = GetLinuxFilesystemType(filePath);
+                }
+
+                if (isWine || IsProbablyWine())
+                {
+                    switch (detected)
+                    {
+                        case FilesystemType.NTFS:
+                        case FilesystemType.Unknown:
+                            {
+                                var linuxDetected = GetLinuxFilesystemType(filePath);
+                                if (linuxDetected != FilesystemType.Unknown)
+                                {
+                                    detected = linuxDetected;
+                                }
+
+                                break;
+                            }
+                    }
+                }
+
+                _filesystemTypeCache[rootPath] = detected;
+                return detected;
+            }
+            catch
+            {
+                return FilesystemType.Unknown;
+            }
+        }
+
+        private static string GetMountPoint(string filePath)
+        {
+            try
+            {
+                var path = Path.GetFullPath(filePath);
+                if (!File.Exists(_mountPath)) return "/";
+                var mounts = File.ReadAllLines(_mountPath);
+
+                string bestMount = "/";
+                foreach (var line in mounts)
+                {
+                    var parts = line.Split(' ');
+                    if (parts.Length < 3) continue;
+                    var mountPoint = parts[1].Replace("\\040", " ", StringComparison.Ordinal);
+
+                    string normalizedMount;
+                    try { normalizedMount = Path.GetFullPath(mountPoint); }
+                    catch { normalizedMount = mountPoint; }
+
+                    if (path.StartsWith(normalizedMount, StringComparison.Ordinal) &&
+                        normalizedMount.Length > bestMount.Length)
+                    {
+                        bestMount = normalizedMount;
+                    }
+                }
+
+                return bestMount;
+            }
+            catch
+            {
+                return "/";
+            }
+        }
+
+        public static string GetMountOptionsForPath(string path)
+        {
+            try
+            {
+                var fullPath = Path.GetFullPath(path);
+                var mounts = File.ReadAllLines("/proc/mounts");
+                string bestMount = string.Empty;
+                string mountOptions = string.Empty;
+
+                foreach (var line in mounts)
+                {
+                    var parts = line.Split(' ');
+                    if (parts.Length < 4) continue;
+                    var mountPoint = parts[1].Replace("\\040", " ", StringComparison.Ordinal);
+                    string normalized;
+                    try { normalized = Path.GetFullPath(mountPoint); }
+                    catch { normalized = mountPoint; }
+
+                    if (fullPath.StartsWith(normalized, StringComparison.Ordinal) &&
+                        normalized.Length > bestMount.Length)
+                    {
+                        bestMount = normalized;
+                        mountOptions = parts[3];
+                    }
+                }
+
+                return mountOptions;
+            }
+            catch (Exception)
+            {
+                return string.Empty;
+            }
+        }
+
+        private static FilesystemType GetLinuxFilesystemType(string filePath)
+        {
+            try
+            {
+                var mountPoint = GetMountPoint(filePath);
+                var mounts = File.ReadAllLines(_mountPath);
+
+                foreach (var line in mounts)
+                {
+                    var parts = line.Split(' ');
+                    if (parts.Length < 3) continue;
+                    var mount = parts[1].Replace("\\040", " ", StringComparison.Ordinal);
+                    if (string.Equals(mount, mountPoint, StringComparison.Ordinal))
+                    {
+                        var fstype = parts[2].ToLowerInvariant();
+                        return fstype switch
+                        {
+                            "btrfs" => FilesystemType.Btrfs,
+                            "ext4" => FilesystemType.Ext4,
+                            "xfs" => FilesystemType.Xfs,
+                            "zfs" => FilesystemType.Zfs,
+                            "apfs" => FilesystemType.Apfs,
+                            "hfsplus" => FilesystemType.HfsPlus,
+                            _ => FilesystemType.Unknown
+                        };
+                    }
+                }
+
+                return FilesystemType.Unknown;
+            }
+            catch
+            {
+                return FilesystemType.Unknown;
+            }
+        }
+
+        public static int GetBlockSizeForPath(string path, ILogger? logger = null, bool isWine = false)
+        {
+            try
+            {
+                if (string.IsNullOrWhiteSpace(path))
+                    return _defaultBlockSize;
+
+                var fi = new FileInfo(path);
+                if (!fi.Exists)
+                    return _defaultBlockSize;
+
+                var root = fi.Directory?.Root.FullName.ToLowerInvariant() ?? "/";
+                if (_blockSizeCache.TryGetValue(root, out int cached))
+                    return cached;
+
+                if (OperatingSystem.IsWindows() && !isWine)
+                {
+                    int result = GetDiskFreeSpaceW(root,
+                        out uint sectorsPerCluster,
+                        out uint bytesPerSector,
+                        out _,
+                        out _);
+
+                    if (result == 0)
+                    {
+                        logger?.LogWarning("Failed to determine block size for {root}", root);
+                        return _defaultBlockSize;
+                    }
+
+                    int clusterSize = (int)(sectorsPerCluster * bytesPerSector);
+                    _blockSizeCache[root] = clusterSize;
+                    logger?.LogTrace("NTFS cluster size for {root}: {cluster}", root, clusterSize);
+                    return clusterSize;
+                }
+
+                return _defaultBlockSize;
+            }
+            catch (Exception ex)
+            {
+                logger?.LogTrace(ex, "Error determining block size for {path}", path);
+                return _defaultBlockSize;
+            }
+        }
+
+        [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);
+
+        //Extra check on 
+        public static bool IsProbablyWine() => Environment.GetEnvironmentVariable("WINELOADERNOEXEC") != null || Environment.GetEnvironmentVariable("WINEDLLPATH") != null || Directory.Exists("/proc/self") && File.Exists("/proc/mounts");
+    }
+}

LightlessCompactorWorker/LightlessCompactorWorker.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LightlessCompactor\LightlessCompactor.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Console" Version="10.0.1" />
+  </ItemGroup>
+
+</Project>

LightlessCompactorWorker/Program.cs

@@ -0,0 +1,270 @@
+using LightlessSync.FileCache;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+using System.IO.Pipes;
+using System.Text.Json;
+
+internal sealed class WorkerCompactorContext : ICompactorContext
+{
+    public WorkerCompactorContext(string cacheFolder, bool isWine)
+    {
+        CacheFolder = cacheFolder;
+        IsWine = isWine;
+    }
+
+    public bool UseCompactor => true;
+    public string CacheFolder { get; }
+    public bool IsWine { get; }
+}
+
+internal sealed class WorkerOptions
+{
+    public string? FilePath { get; init; }
+    public bool IsWine { get; init; }
+    public string CacheFolder { get; init; } = string.Empty;
+    public LogLevel LogLevel { get; init; } = LogLevel.Information;
+    public string PipeName { get; init; } = "LightlessCompactor";
+    public int? ParentProcessId { get; init; }
+}
+
+internal static class Program
+{
+    public static async Task<int> Main(string[] args)
+    {
+        var options = ParseOptions(args, out var error);
+        if (options is null)
+        {
+            Console.Error.WriteLine(error ?? "Invalid arguments.");
+            Console.Error.WriteLine("Usage: LightlessCompactorWorker --file <path> [--wine] [--cache-folder <path>] [--verbose]");
+            Console.Error.WriteLine("   or: LightlessCompactorWorker --pipe <name> [--wine] [--parent <pid>] [--verbose]");
+            return 2;
+        }
+
+        TrySetLowPriority();
+
+        using var loggerFactory = LoggerFactory.Create(builder =>
+        {
+            builder.SetMinimumLevel(options.LogLevel);
+            builder.AddSimpleConsole(o =>
+            {
+                o.SingleLine = true;
+                o.TimestampFormat = "HH:mm:ss.fff ";
+            });
+        });
+
+        var logger = loggerFactory.CreateLogger<FileCompactor>();
+        var context = new WorkerCompactorContext(options.CacheFolder, options.IsWine);
+
+        using var compactor = new FileCompactor(logger, context, new NoopCompactionExecutor());
+
+        if (!string.IsNullOrWhiteSpace(options.FilePath))
+        {
+            var success = compactor.TryCompactFile(options.FilePath!);
+            return success ? 0 : 1;
+        }
+
+        var serverLogger = loggerFactory.CreateLogger("CompactorWorker");
+        return await RunServerAsync(compactor, options, serverLogger).ConfigureAwait(false);
+    }
+
+    private static async Task<int> RunServerAsync(FileCompactor compactor, WorkerOptions options, ILogger serverLogger)
+    {
+        using var cts = new CancellationTokenSource();
+        var token = cts.Token;
+
+        if (options.ParentProcessId.HasValue)
+        {
+            _ = Task.Run(() => MonitorParent(options.ParentProcessId.Value, cts));
+        }
+
+        serverLogger.LogInformation("Compactor worker listening on pipe {pipe}", options.PipeName);
+
+        try
+        {
+            while (!token.IsCancellationRequested)
+            {
+                var server = new NamedPipeServerStream(
+                    options.PipeName,
+                    PipeDirection.InOut,
+                    NamedPipeServerStream.MaxAllowedServerInstances,
+                    PipeTransmissionMode.Byte,
+                    PipeOptions.Asynchronous);
+
+                try
+                {
+                    await server.WaitForConnectionAsync(token).ConfigureAwait(false);
+                }
+                catch
+                {
+                    server.Dispose();
+                    throw;
+                }
+
+                _ = Task.Run(() => HandleClientAsync(server, compactor, cts));
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            // shutdown requested
+        }
+        catch (Exception ex)
+        {
+            serverLogger.LogWarning(ex, "Compactor worker terminated unexpectedly.");
+            return 1;
+        }
+
+        return 0;
+    }
+
+    private static async Task HandleClientAsync(NamedPipeServerStream pipe, FileCompactor compactor, CancellationTokenSource shutdownCts)
+    {
+        await using var _ = pipe;
+        using var reader = new StreamReader(pipe);
+        using var writer = new StreamWriter(pipe) { AutoFlush = true };
+
+        var line = await reader.ReadLineAsync().ConfigureAwait(false);
+        if (string.IsNullOrWhiteSpace(line))
+            return;
+
+        CompactorRequest? request = null;
+        try
+        {
+            request = JsonSerializer.Deserialize<CompactorRequest>(line);
+        }
+        catch
+        {
+            // ignore
+        }
+
+        CompactorResponse response;
+        if (request is null)
+        {
+            response = new CompactorResponse { Success = false, Error = "Invalid request." };
+        }
+        else if (string.Equals(request.Type, "shutdown", StringComparison.OrdinalIgnoreCase))
+        {
+            shutdownCts.Cancel();
+            response = new CompactorResponse { Success = true };
+        }
+        else if (string.Equals(request.Type, "compact", StringComparison.OrdinalIgnoreCase))
+        {
+            var success = compactor.TryCompactFile(request.Path ?? string.Empty);
+            response = new CompactorResponse { Success = success };
+        }
+        else
+        {
+            response = new CompactorResponse { Success = false, Error = "Unknown request type." };
+        }
+
+        await writer.WriteLineAsync(JsonSerializer.Serialize(response)).ConfigureAwait(false);
+    }
+
+    private static void MonitorParent(int parentPid, CancellationTokenSource shutdownCts)
+    {
+        try
+        {
+            var parent = Process.GetProcessById(parentPid);
+            parent.WaitForExit();
+        }
+        catch
+        {
+            // parent missing
+        }
+        finally
+        {
+            shutdownCts.Cancel();
+        }
+    }
+
+    private static WorkerOptions? ParseOptions(string[] args, out string? error)
+    {
+        string? filePath = null;
+        bool isWine = false;
+        string cacheFolder = string.Empty;
+        var logLevel = LogLevel.Information;
+        string pipeName = "LightlessCompactor";
+        int? parentPid = null;
+
+        for (int i = 0; i < args.Length; i++)
+        {
+            var arg = args[i];
+            switch (arg)
+            {
+                case "--file":
+                    if (i + 1 >= args.Length)
+                    {
+                        error = "Missing value for --file.";
+                        return null;
+                    }
+                    filePath = args[++i];
+                    break;
+                case "--cache-folder":
+                    if (i + 1 >= args.Length)
+                    {
+                        error = "Missing value for --cache-folder.";
+                        return null;
+                    }
+                    cacheFolder = args[++i];
+                    break;
+                case "--pipe":
+                    if (i + 1 >= args.Length)
+                    {
+                        error = "Missing value for --pipe.";
+                        return null;
+                    }
+                    pipeName = args[++i];
+                    break;
+                case "--parent":
+                    if (i + 1 >= args.Length || !int.TryParse(args[++i], out var pid))
+                    {
+                        error = "Invalid value for --parent.";
+                        return null;
+                    }
+                    parentPid = pid;
+                    break;
+                case "--wine":
+                    isWine = true;
+                    break;
+                case "--verbose":
+                    logLevel = LogLevel.Trace;
+                    break;
+            }
+        }
+
+        error = null;
+        return new WorkerOptions
+        {
+            FilePath = filePath,
+            IsWine = isWine,
+            CacheFolder = cacheFolder,
+            LogLevel = logLevel,
+            PipeName = pipeName,
+            ParentProcessId = parentPid
+        };
+    }
+
+    private static void TrySetLowPriority()
+    {
+        try
+        {
+            if (OperatingSystem.IsWindows())
+                Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.BelowNormal;
+        }
+        catch
+        {
+            // ignore
+        }
+    }
+
+    private sealed class CompactorRequest
+    {
+        public string Type { get; init; } = "compact";
+        public string? Path { get; init; }
+    }
+
+    private sealed class CompactorResponse
+    {
+        public bool Success { get; init; }
+        public string? Error { get; init; }
+    }
+}

LightlessSync.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.1.32328.378
+# Visual Studio Version 18
+VisualStudioVersion = 18.0.11217.181
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{585B740D-BA2C-429B-9CF3-B2D223423748}"
 	ProjectSection(SolutionItems) = preProject
@@ -12,30 +12,138 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LightlessSync", "LightlessS
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LightlessSync.API", "LightlessAPI\LightlessSyncAPI\LightlessSync.API.csproj", "{A4E42AFA-5045-7E81-937F-3A320AC52987}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Penumbra.String", "Penumbra.String\Penumbra.String.csproj", "{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Penumbra.Api", "Penumbra.Api\Penumbra.Api.csproj", "{22AE06C8-5139-45D2-A5F9-E76C019050D9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Penumbra.GameData", "Penumbra.GameData\Penumbra.GameData.csproj", "{3C016B19-2A2C-4068-9378-B9B805605EFB}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "OtterGui", "OtterGui\OtterGui.csproj", "{C77A2833-3FE4-405B-811D-439B1FF859D9}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Pictomancy", "ffxiv_pictomancy\Pictomancy\Pictomancy.csproj", "{825F17D8-2704-24F6-DF8B-2542AC92C765}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LightlessCompactor", "LightlessCompactor\LightlessCompactor.csproj", "{01F31917-9F1E-426D-BDAE-17268CBF9523}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LightlessCompactorWorker", "LightlessCompactorWorker\LightlessCompactorWorker.csproj", "{72BE3664-CD0E-4DA4-B040-91338A2798E0}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
 		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
 		Release|Any CPU = Release|Any CPU
 		Release|x64 = Release|x64
+		Release|x86 = Release|x86
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Debug|Any CPU.ActiveCfg = Release|x64
-		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Debug|Any CPU.Build.0 = Release|x64
+		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Debug|Any CPU.Build.0 = Debug|x64
 		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Debug|x64.ActiveCfg = Debug|x64
 		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Debug|x64.Build.0 = Debug|x64
+		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Debug|x86.Build.0 = Debug|Any CPU
 		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Release|Any CPU.ActiveCfg = Release|x64
 		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Release|Any CPU.Build.0 = Release|x64
 		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Release|x64.ActiveCfg = Release|x64
 		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Release|x64.Build.0 = Release|x64
-		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Debug|Any CPU.ActiveCfg = Release|Any CPU
-		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Debug|Any CPU.Build.0 = Release|Any CPU
+		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Release|x86.ActiveCfg = Release|Any CPU
+		{BB929046-4CD2-B174-EBAA-C756AC3AC8DA}.Release|x86.Build.0 = Release|Any CPU
+		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Debug|x64.ActiveCfg = Debug|Any CPU
 		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Debug|x64.Build.0 = Debug|Any CPU
+		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Debug|x86.Build.0 = Debug|Any CPU
 		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Release|Any CPU.Build.0 = Release|Any CPU
 		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Release|x64.ActiveCfg = Release|Any CPU
 		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Release|x64.Build.0 = Release|Any CPU
+		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Release|x86.ActiveCfg = Release|Any CPU
+		{A4E42AFA-5045-7E81-937F-3A320AC52987}.Release|x86.Build.0 = Release|Any CPU
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Debug|Any CPU.Build.0 = Debug|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Debug|x64.ActiveCfg = Debug|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Debug|x64.Build.0 = Debug|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Debug|x86.ActiveCfg = Debug|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Debug|x86.Build.0 = Debug|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Release|Any CPU.ActiveCfg = Release|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Release|Any CPU.Build.0 = Release|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Release|x64.ActiveCfg = Release|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Release|x64.Build.0 = Release|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Release|x86.ActiveCfg = Release|x64
+		{82DFB180-DD4C-4C48-919C-B5C5C77FC0FD}.Release|x86.Build.0 = Release|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Debug|Any CPU.Build.0 = Debug|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Debug|x64.ActiveCfg = Debug|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Debug|x64.Build.0 = Debug|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Debug|x86.ActiveCfg = Debug|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Debug|x86.Build.0 = Debug|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Release|Any CPU.ActiveCfg = Release|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Release|Any CPU.Build.0 = Release|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Release|x64.ActiveCfg = Release|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Release|x64.Build.0 = Release|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Release|x86.ActiveCfg = Release|x64
+		{22AE06C8-5139-45D2-A5F9-E76C019050D9}.Release|x86.Build.0 = Release|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Debug|Any CPU.Build.0 = Debug|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Debug|x64.ActiveCfg = Debug|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Debug|x64.Build.0 = Debug|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Debug|x86.ActiveCfg = Debug|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Debug|x86.Build.0 = Debug|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Release|Any CPU.ActiveCfg = Release|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Release|Any CPU.Build.0 = Release|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Release|x64.ActiveCfg = Release|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Release|x64.Build.0 = Release|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Release|x86.ActiveCfg = Release|x64
+		{3C016B19-2A2C-4068-9378-B9B805605EFB}.Release|x86.Build.0 = Release|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Debug|Any CPU.Build.0 = Debug|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Debug|x64.ActiveCfg = Debug|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Debug|x64.Build.0 = Debug|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Debug|x86.ActiveCfg = Debug|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Debug|x86.Build.0 = Debug|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Release|Any CPU.ActiveCfg = Release|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Release|Any CPU.Build.0 = Release|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Release|x64.ActiveCfg = Release|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Release|x64.Build.0 = Release|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Release|x86.ActiveCfg = Release|x64
+		{C77A2833-3FE4-405B-811D-439B1FF859D9}.Release|x86.Build.0 = Release|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Debug|Any CPU.ActiveCfg = Debug|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Debug|Any CPU.Build.0 = Debug|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Debug|x64.ActiveCfg = Debug|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Debug|x64.Build.0 = Debug|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Debug|x86.ActiveCfg = Debug|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Debug|x86.Build.0 = Debug|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Release|Any CPU.ActiveCfg = Release|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Release|Any CPU.Build.0 = Release|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Release|x64.ActiveCfg = Release|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Release|x64.Build.0 = Release|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Release|x86.ActiveCfg = Release|x64
+		{825F17D8-2704-24F6-DF8B-2542AC92C765}.Release|x86.Build.0 = Release|x64
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Debug|x64.Build.0 = Debug|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Debug|x86.Build.0 = Debug|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Release|Any CPU.Build.0 = Release|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Release|x64.ActiveCfg = Release|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Release|x64.Build.0 = Release|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Release|x86.ActiveCfg = Release|Any CPU
+		{01F31917-9F1E-426D-BDAE-17268CBF9523}.Release|x86.Build.0 = Release|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Debug|x64.Build.0 = Debug|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Debug|x86.Build.0 = Debug|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Release|x64.ActiveCfg = Release|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Release|x64.Build.0 = Release|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Release|x86.ActiveCfg = Release|Any CPU
+		{72BE3664-CD0E-4DA4-B040-91338A2798E0}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

LightlessSync/Changelog/changelog.yaml

@@ -0,0 +1,340 @@
+tagline: "Lightless Sync v2.0.1"
+subline: "LIGHTLESS IS EVOLVING!!"
+changelog:
+  - name: "v2.0.2"
+    tagline: "Last update of 2025!... ... ... If Nothing breaks"
+    date: "December 28 2025"
+   # be sure to set this every new version
+    isCurrent: true
+    versions:
+      - number: "Chat"
+        icon: ""
+        items:
+          - "Added a 7TV emote picker to chat. You’ll now see a new button next to Send that opens an emote selector."
+          - "Pin User, Remove User, and Ban User (including Syncshell) have been added when you right click a user in chat."
+          - "Chatters now show status icons/labels in the Syncshell (e.g., Owner, Moderator, and Pinned when applicable)."
+          - "The Rules page no longer blocks input for other open Lightless UI windows."
+      - number: "LightFinder"
+        icon: ""
+        items:
+          - "If the ImGui Lightfinder icons aren’t working correctly, you can switch back to the Nameplate signature hook. Important warning - USE AT YOUR OWN RISK: The native nameplate hook can crash the game if multiple plugins hook the nameplate function at the same time. We will not provide support about Nameplate crashes, nor will the Dalamud team, **DO NOT BOTHER THEM.**"
+          - "The LightFinder label in the menu has a counter next to it showing the number of broadcasting users."
+          - "There is less interference of hidden UI elements for the imGui renderer of LightFinder."
+      - number: "Miscellaneous fixes"
+        icon: ""
+        items:
+          - "Overhauled transient resources in an attempt to mitigate mount and minion problems."
+          - "Some file cache entries will now be cached to reduce load on your game."
+          - "Downloading and decompressing have been redone to fix the locking issues."
+          - "Disabling the context menu will now hide the context menu on right clicks again. (Thanks @infiniti)"
+          - "Temporary collections that were not cleared before will now be cleared when the plugin starts."
+          - "Pair requests will now appear in chat if notifications are not enabled or on chat mode."
+          - "Fixed an instance were an object may be null in the Download UI."
+          - "API 14 - Migrate to IPlayerState service"
+  - name: "v2.0.1"
+    tagline: "Some Fixes"
+    date: "December 23 2025"
+    versions:
+      - number: "Chat"
+        icon: ""
+        items:
+          - "You can turn off the syncshell chat as Owner by going to the Syncshell Admin panel -> Owner -> Enable/Disable Chat."
+          - "Fixed an issue where you can't chat due to regions being in a different language."
+      - number: "LightFinder"
+        icon: ""
+        items:
+          - "The icon/Lightfinder Text will be hidden when Game UI is hidden and behind game elements/UI"
+          - "Able to select an icon for the selected list or a custom glyph if you know the code."
+          - "Smoothing and reducing jitter on the icon/Lightfinder Text."
+          - "Fixed so higher scaled UI options (100/150/200% UI scale) wouldn't break the element."
+          - "Detects if GPose is active, wouldn't render the elements"
+      - number: "Miscellaneous fixes"
+        icon: ""
+        items:
+          - "Fixed the null error given on GetCID when transferring between zones/housing."
+          - "Added push/pop on certain ImGUI elements to remove them after being used. "
+          - "Having all tabs open in the Main UI wouldn't lag out the game anymore."
+          - "Cycle pause has been adjusted to the old function. There is a separate button to pause normally, now called 'Toggle (Un)Pause State'."
+          - "Changes have been made to the character redraw to address the issues with the building character data constantly being redrawn and the redrawn behavior with Honorific titles."
+          - "GPose characters should appear again in the actor screen"
+          - "Lightspeed download console messages are no longer shown as warnings."
+      - number: "Server Updates"
+        icon: ""
+        items:
+          - "Changes have been made to the disabling of your profile. It should save again."
+          - "Ability added to toggle chats from syncshell to be disabled."
+          - "Files are continuously being deleted due to high volumes in storage, potentially causing MCDOs to have missing files. We have increased the limit of the storage in our configurations to see if that helps."
+  - name: "v2.0.0"
+    tagline: "Thank you for 4 months!"
+    date: "December 2025"
+    versions:
+      - number: "Lightless Chat"
+        icon: ""
+        items:
+          - "Chat has been added to the top of the main UI. It will work in certain Zones or in Syncshells!"
+          - "You will only be able to use the chat feature after enabling it and accepting the rules. If you're not interested, don't use it!"
+          - "Breaking the rules may result in a mute or ban from chat. Serious offenses may result in a ban from the Lightless service altogether."
+          - "You can right click the offender in the chat and report them within the chat, reports will be reviewed asap."
+          - "Syncshells can enforce their own chat rules and moderate their own chat. This however does not apply to serious offenses."
+          - "Your name in chat will not be shown unless you are paired with the person OR you are in the same syncshell. Otherwise, you will be anonymous."
+          - "Refer to #release-notes in the Discord for more information. Feel free to ask questions in the Discord as well." 
+      - number: "Changes to LightFinder"
+        icon: ""
+        items:
+          - "We have recieve quite a bit of reports of users crashing due to how Nameplates are handled across various plugins. As a result, we have moved the LightFinder icon and text to Imgui."
+          - "This should resolve the crashing issues, however, it may not look as nice as before. We are looking into ways to improve the Imgui experience in the future."
+          - "We will always prioritize stability and safety over visuals." 
+          - "Refer to #release-notes in the Discord for an example of the error."
+      - number: "User Profiles, ShellFinder, Syncshells, Syncshell Profiles"
+        icon: ""
+        items:
+          - "Both User Profiles and Syncshell Profiles have been revamped for 2.0.0."
+          - "We have added profile tags to both Users and Syncshells that will show when a profile is being viewed"
+          - "Syncshell Admin Panel has been reworked to make it a friendlier experience"
+          - "Syncshell Moderators can now also broadcast on ShellFinder"
+          - "ShellFinder has been revamped to be more visually friends and also show more information (Tags) about the Syncshell"
+          - "Syncshells has an auto-prune feature now that will remove inactive members after a set amount of time, options available are 1, 3, 7, and 14 days that runs in 1 hour intervals"
+          - "IF YOUR SYNCSHELL IS NSFW, PLEASE MARK IT AS NSFW!"
+          - "Refer to #release-notes in the Discord for pretty pictures or try it yourself!."
+      - number: "Texture Optimization"
+        icon: ""
+        items:
+          - "In 2.0.0, we've added the option for Texture Optimization to improve the performance of scenarios such as overwhelmingly big "
+          - "NOTE: ALL OF THESE ARE OPTIONAL AND DISABLED BY DEFAULT"
+          - "Within Texture Optimization, you will be able to safely downscale all textures of new downloads around you."
+          - "This downscale DOES NOT APPLY to DIRECT PAIRS or those who've updated their preferred settings to not be downscaled" 
+          - "The first time this is enabled, you may experience some lag or frame drops, but in the long run, it will help performance."
+          - "This can be found in Lightless Settings > Performance > Texture Optimization"
+          - "Like a broken record, please refer to #release-notes in the Discord for more information."
+      - number: "Character Analysis - The big scary UI no one knew about"
+        icon: ""
+        items:
+          - "We have made the Character Analysis UI more user friendly. This includes a revamp of the look and functionality"
+          - "You can now see more information about your character and how it affects performance"
+          - "It will show you the Textures tab by default with an option for \"Other file types\""
+          - "You can now choose if you want to BC7/BC5/BC4/BC3/BC1 compress a certain texture."
+          - "The UI will give you a recommendation on what BC compression to use based on the file." 
+          - "Shows a small preview of what the texture looks like with some general info about it." 
+          - "Shows you how much VRAM you would take up." 
+          - "This can be found in Lightless Settings > Performance > Character Analysis"
+      - number: "Performance"
+        icon: ""
+        items:
+          - "Moved to the internal object table to have improved overall plugin performance."
+          - "Compactor is now running on a multi-threaded level instead of single-threaded; This should increase the speed of compacting files."
+          - "Penumbra Collections are now only made when people are visible, reducing the load on boot-up when having many Syncshells in your list."
+          - "Pairing system has been revamped to make pausing and unpausing faster, and loading people should be faster as well."
+      - number: "Miscellaneous Changes and Bugfixes"
+        icon: ""
+        items:
+          - "UI has been updated to look more modern"
+          - "We have started on file compression for Linux with the option for BTRFS or ZFS but it's not very great yet and will release later."
+          - "Nameplate colours now use sigs to client structs as an alternative to the Nameplate Handler, also preventing crashes on that from our end." 
+          - "Notifications now work with the \"Enable multi-monitor windows\" settings of Dalamud."
+          - "Fixed a bug where nothing above the notifications was clickable in certain cases."
+          - "Added a check that prevents small messages from going below 0 resulting in an ArgumentOutOfRangeException."
+  - name: "v1.12.4"
+    tagline: "Preparation for future features"
+    date: "November 11th 2025"
+    versions:
+      - number: "Syncshells"
+        icon: ""
+        items:
+          - "Added a pause button for syncshells in grouped folders"
+      - number: "Notifications"
+        icon: ""
+        items:
+          - "Fixed download notifications getting stuck at times"
+          - "Added more offset positions for the notifications"  
+      - number: "Lightfinder"
+        icon: ""
+        items:
+          - "Pair button will now show up when you're not directly paired. ie. You are technically paired in a syncshell, but you may not be directly paired'"
+          - "Fixed a problem where the number of LightFinder users were cached, displaying the wrong information"
+          - "When LightFinder is enabled, if you hover over the number of users, it will show you how many users are also using LightFinder in your area"
+          - 
+      - number: "Bugfixes"
+        icon: ""
+        items:
+          - "Added even more checks to nameplate handler to help not only us debug, but also other plugins writing to the plate"
+      - number: "Miscellaneous Changes"
+        icon: ""
+        items:
+          - "Default Linux to Websockets"
+          - "Revised Brio warning"
+          - "Added /lightless command to open Lightless UI (you can still use /light)" 
+          - "Initial groundwork for future features"
+  - name: "v1.12.3"
+    tagline: "LightSpeed, Welcome Screen, and More!"
+    date: "October 15th 2025"
+    versions:
+      - number: "LightSpeed"
+        icon: ""
+        items:
+          - "New way to download that will download mods directly from the file server"
+          - "LightSpeed is in BETA and should be faster than the batch downloading"
+      - number: "Welcome Screen + Additional Features"
+        icon: ""
+        items:
+          - "New in-game Patch Notes window."
+          - "Credits section to thank contributors and supporters."
+          - "Patch notes only show after updates, not during first-time setup."
+          - "Syncshell Rework stared: Profiles have been added (more features using this will come later)."
+      - number: "Notifications"
+        icon: ""
+        items:
+          - "More customizable notification options."
+          - "Perfomance limiter shows as notifications."
+          - "All notifications can be configured or disabled in Settings → Notifications."
+          - "Cleaning up notifications implementation"
+      - number: "Bugfixes"
+        icon: ""
+        items:
+          - "Added more safety checks to nameplates"
+          - "Removed a line in SyncshellUI potentially causing NullPointers"
+          - "Additional safety checks in PlayerData.Factory"
+  - name: "v1.12.2"
+    tagline: "LightFinder fixes, Notifications overhaul"
+    date: "October 12th 2025"
+    versions:
+      - number: "LightFinder"
+        icon: ""
+        items:
+          - "Server-side improvements for LightFinder functionality."
+          - "Command changed from '/light lightfinder' to '/light finder'."
+          - "Option to enable LightFinder on connection (opt-in, refreshes every 3 hours)."
+          - "LightFinder indicator can now be shown on the server info bar."
+      - number: "Notifications"
+        icon: ""
+        items:
+          - "Completely reworked notification system with new UI."
+          - "Pair requests now show as notifications."
+          - "Download progress shows as notifications."
+          - "Customizable notification sounds, size, position, and duration."
+          - "All notifications can be configured or disabled in Settings → Notifications."
+      - number: "Bug Fixes"
+        icon: ""
+        items:
+          - "Fixed nameplate alignment issues with LightFinder and icons."
+          - "Icons now properly apply instead of swapping on choice."
+          - "Updated Discord URL."
+          - "File cache logic improvements."
+
+  - name: "v1.12.1"
+    tagline: "LightFinder customization and download limiter"
+    date: "October 8th 2025"
+    versions:
+      - number: "New Features"
+        icon: ""
+        items:
+          - "LightFinder text can be modified to an icon with customizable positioning."
+          - "Option to hide your own indicator or paired player indicators."
+          - "Pair Download Limiter: Limit simultaneous downloads to 1-6 users to reduce network strain."
+          - "Added '/light lightfinder' command to open LightFinder UI."
+      - number: "Improvements"
+        icon: ""
+        items:
+          - "Right-click menu option for Send Pair Request can be disabled."
+          - "Syncshell finder improvements."
+          - "Download limiter settings available in Settings → Transfers."
+
+  - name: "v1.12.0"
+    tagline: "LightFinder - Major feature release"
+    date: "October 5th 2025"
+    versions:
+      - number: "Major Features"
+        icon: ""
+        items:
+          - "Introduced LightFinder: Optional feature inspired by FFXIV's Party Finder."
+          - "Find fellow Lightless users and advertise your Syncshell to others."
+          - "When enabled, you're visible to other LightFinder users for 3 hours."
+          - "LightFinder tag displays above your nameplate when active."
+          - "Receive pair requests directly in UI without exchanging UIDs."
+          - "Syncshell Finder allows joining indexed Syncshells."
+          - "[L] Send Pair Request added to player context menus."
+      - number: "Vanity Features"
+        icon: ""
+        items:
+          - "Supporters can now customize their name color in the Lightless UI."
+          - "Color changes visible to all users."
+      - number: "General Improvements"
+        icon: ""
+        items:
+          - "Pairing nameplate color override can now override FC tags."
+          - "Added .kdb as whitelisted filetype for uploads."
+          - "Various UI fixes, updates, and improvements."
+
+  - name: "v1.11.12"
+    tagline: "Syncshell grouping and performance options"
+    date: "September 16th 2025"
+    versions:
+      - number: "New Features"
+        icon: ""
+        items:
+          - "Ability to show grouped syncshells in main UI/all syncshells (default ON)."
+          - "Transfer ownership button available in Admin Panel user list."
+          - "Self-threshold warning now opens character analysis screen when clicked."
+      - number: "Performance"
+        icon: ""
+        items:
+          - "Auto-pause combat and auto-pause performance are now optional settings."
+          - "Both options are auto-enabled by default - disable at your own risk."
+      - number: "Bug Fixes"
+        icon: ""
+        items:
+          - "Reworked file caching to reduce errors for some users."
+          - "Fixed bug where exiting PvP could desync some users."
+
+  - name: "v1.11.9"
+    tagline: "File cache improvements"
+    date: "September 13th 2025"
+    versions:
+      - number: "Bug Fixes"
+        icon: ""
+        items:
+          - "Identified and fixed potential file cache problems."
+          - "Improved cache error handling and stability."
+
+  - name: "v1.11.8"
+    tagline: "Hotfix - UI and exception handling"
+    date: "September 12th 2025"
+    versions:
+      - number: "Bug Fixes"
+        icon: ""
+        items:
+          - "Attempted fix for NullReferenceException spam."
+          - "Fixed additional UI edge cases preventing loading for some users."
+          - "Fixed color bar UI issues."
+
+  - name: "v1.11.7"
+    tagline: "Hotfix - UI loading and warnings"
+    date: "September 12th 2025"
+    versions:
+      - number: "Bug Fixes"
+        icon: ""
+        items:
+          - "Fixed UI not loading for some users."
+          - "Self warnings now behind 'Warn on loading in players exceeding performance thresholds' setting."
+
+  - name: "v1.11.6"
+    tagline: "Admin panel rework and new features"
+    date: "September 11th 2025"
+    versions:
+      - number: "New Features"
+        icon: ""
+        items:
+          - "Reworked Syncshell Admin Page with improved styling."
+          - "Right-click on Server Top Bar button to disconnect from Lightless."
+          - "Shift+Left click on Server Top Bar button to open settings."
+          - "Added colors section in settings to change accent colors."
+          - "Ability to pause syncing while in Instance/Duty."
+          - "Functionality to create syncshell folders."
+          - "Added self-threshold warning."
+      - number: "Bug Fixes"
+        icon: ""
+        items:
+          - "Fixed owners being visible in moderator list view."
+          - "Removed Pin/Remove/Ban buttons on Owners when viewing as moderator."
+          - "Fixed nameplate bug in PvP."
+          - "Added 1 or 3 day options for inactive check."
+          - "Fixed bug where some users could not see their own syncshell folders."

LightlessSync/Changelog/credits.yaml

@@ -0,0 +1,68 @@
+credits:
+  - category: "Development Team"
+    items:
+      - name: "Abel"
+        role: "Developer"
+      - name: "Cake"
+        role: "Developer"
+      - name: "Celine"
+        role: "Developer"
+      - name: "Choco"
+        role: "Developer"
+      - name: "Kenny"
+        role: "Developer"
+      - name: "Zura"
+        role: "Developer"
+      - name: "Additional Contributors"
+        role: "Community Contributors & Bug Reporters"
+
+  - category: "Moderation Team"
+    items:
+      - name: "Crow"
+        role: "Moderator"
+      - name: "Faith"
+        role: "Moderator"
+      - name: "Kiwiwiwi"
+        role: "Moderator"
+      - name: "Kruwu"
+        role: "Moderator"
+      - name: "Lexi"
+        role: "Moderator"
+      - name: "Maya"
+        role: "Moderator"
+      - name: "Metaknight"
+        role: "Moderator"
+      - name: "Minmoose"
+        role: "Moderator"
+      - name: "Nihal"
+        role: "Moderator"
+      - name: "Tani"
+        role: "Moderator"
+
+  - category: "Plugin Integration & IPC Support"
+    items:
+      - name: "Penumbra Team"
+        role: "Mod framework integration"
+      - name: "Glamourer Team"
+        role: "Customization system integration"
+      - name: "Customize+ Team"
+        role: "Body scaling integration"
+      - name: "Simple Heels Team"
+        role: "Height offset integration"
+      - name: "Honorific Team"
+        role: "Title system integration"
+      - name: "Glyceri"
+        role: "Moodles - Status effect integration"
+      - name: "Glyceri"
+        role: "PetNicknames - Pet naming integration"
+      - name: "Minmoose"
+        role: "Brio - GPose enhancement integration"
+ 
+  - category: "Special Thanks"
+    items:
+      - name: "Dalamud & XIVLauncher Teams"
+        role: "Plugin framework and infrastructure"
+      - name: "Community Supporters"
+        role: "Testing, feedback, and financial support"
+      - name: "Beta Testers"
+        role: "Early testing and bug reporting"

LightlessSync/FileCache/CacheMonitor.cs

@@ -6,6 +6,7 @@ using LightlessSync.Utils;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
 using System.Collections.Immutable;
+using System.IO;
 
 namespace LightlessSync.FileCache;
 
@@ -20,7 +21,8 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     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 static readonly IImmutableList<string> AllowedFileExtensions = [".mdl", ".tex", ".mtrl", ".tmb", ".pap", ".avfx", ".atex", ".sklb", ".eid", ".phyb", ".pbd", ".scd", ".skp", ".shpk", ".kdb"];
+    private static readonly HashSet<string> AllowedFileExtensionSet = new(AllowedFileExtensions, StringComparer.OrdinalIgnoreCase);
 
     public CacheMonitor(ILogger<CacheMonitor> logger, IpcManager ipcManager, LightlessConfigService configService,
         FileCacheManager fileDbManager, LightlessMediator mediator, PerformanceCollectorService performanceCollector, DalamudUtilService dalamudUtil,
@@ -72,7 +74,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
                 {
                     while (_dalamudUtil.IsOnFrameworkThread && !token.IsCancellationRequested)
                     {
-                        await Task.Delay(1).ConfigureAwait(false);
+                        await Task.Delay(1, token).ConfigureAwait(false);
                     }
 
                     RecalculateFileCacheSize(token);
@@ -101,8 +103,9 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     }
 
     record WatcherChange(WatcherChangeTypes ChangeType, string? OldPath = null);
-    private readonly Dictionary<string, WatcherChange> _watcherChanges = new Dictionary<string, WatcherChange>(StringComparer.OrdinalIgnoreCase);
-    private readonly Dictionary<string, WatcherChange> _lightlessChanges = new Dictionary<string, WatcherChange>(StringComparer.OrdinalIgnoreCase);
+    private readonly record struct CacheEvictionCandidate(string FullPath, long Size, DateTime LastAccessTime);
+    private readonly Dictionary<string, WatcherChange> _watcherChanges = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, WatcherChange> _lightlessChanges = new(StringComparer.OrdinalIgnoreCase);
 
     public void StopMonitoring()
     {
@@ -115,6 +118,8 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
 
     public bool StorageisNTFS { get; private set; } = false;
 
+    public bool StorageIsBtrfs { get ; private set; } = false;
+
     public void StartLightlessWatcher(string? lightlessPath)
     {
         LightlessWatcher?.Dispose();
@@ -124,10 +129,19 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
             Logger.LogWarning("Lightless file path is not set, cannot start the FSW for Lightless.");
             return;
         }
+        var fsType = FileSystemHelper.GetFilesystemType(_configService.Current.CacheFolder, _dalamudUtil.IsWine);
 
-        DriveInfo di = new(new DirectoryInfo(_configService.Current.CacheFolder).Root.FullName);
-        StorageisNTFS = string.Equals("NTFS", di.DriveFormat, StringComparison.OrdinalIgnoreCase);
+        if (fsType == FileSystemHelper.FilesystemType.NTFS && !_dalamudUtil.IsWine)
+        {
+            StorageisNTFS = true;
             Logger.LogInformation("Lightless Storage is on NTFS drive: {isNtfs}", StorageisNTFS);
+        }
+
+        if (fsType == FileSystemHelper.FilesystemType.Btrfs)
+        {
+            StorageIsBtrfs = true;
+            Logger.LogInformation("Lightless Storage is on BTRFS drive: {isBtrfs}", StorageIsBtrfs);
+        }
 
         Logger.LogDebug("Initializing Lightless FSW on {path}", lightlessPath);
         LightlessWatcher = new()
@@ -152,7 +166,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     {
         Logger.LogTrace("Lightless FSW: FileChanged: {change} => {path}", e.ChangeType, e.FullPath);
 
-        if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+        if (!HasAllowedExtension(e.FullPath)) return;
 
         lock (_watcherChanges)
         {
@@ -196,7 +210,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     private void Fs_Changed(object sender, FileSystemEventArgs e)
     {
         if (Directory.Exists(e.FullPath)) return;
-        if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+        if (!HasAllowedExtension(e.FullPath)) return;
 
         if (e.ChangeType is not (WatcherChangeTypes.Changed or WatcherChangeTypes.Deleted or WatcherChangeTypes.Created))
             return;
@@ -220,7 +234,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
             {
                 foreach (var file in directoryFiles)
                 {
-                    if (!AllowedFileExtensions.Any(ext => file.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) continue;
+                    if (!HasAllowedExtension(file)) continue;
                     var oldPath = file.Replace(e.FullPath, e.OldFullPath, StringComparison.OrdinalIgnoreCase);
 
                     _watcherChanges.Remove(oldPath);
@@ -232,7 +246,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
         }
         else
         {
-            if (!AllowedFileExtensions.Any(ext => e.FullPath.EndsWith(ext, StringComparison.OrdinalIgnoreCase))) return;
+            if (!HasAllowedExtension(e.FullPath)) return;
 
             lock (_watcherChanges)
             {
@@ -248,9 +262,21 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
 
     private CancellationTokenSource _penumbraFswCts = new();
     private CancellationTokenSource _lightlessFswCts = new();
+
     public FileSystemWatcher? PenumbraWatcher { get; private set; }
     public FileSystemWatcher? LightlessWatcher { get; private set; }
 
+    private static bool HasAllowedExtension(string path)
+    {
+        if (string.IsNullOrEmpty(path))
+        {
+            return false;
+        }
+
+        var extension = Path.GetExtension(path);
+        return !string.IsNullOrEmpty(extension) && AllowedFileExtensionSet.Contains(extension);
+    }
+
     private async Task LightlessWatcherExecution()
     {
         _lightlessFswCts = _lightlessFswCts.CancelRecreate();
@@ -383,7 +409,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
             scanThread.Start();
             while (scanThread.IsAlive)
             {
-                await Task.Delay(250).ConfigureAwait(false);
+                await Task.Delay(250, token).ConfigureAwait(false);
             }
             TotalFiles = 0;
             _currentFileProgress = 0;
@@ -392,51 +418,64 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
 
     public void RecalculateFileCacheSize(CancellationToken token)
     {
-        if (string.IsNullOrEmpty(_configService.Current.CacheFolder) || !Directory.Exists(_configService.Current.CacheFolder))
+        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);
+        bool isWine = _dalamudUtil?.IsWine ?? false;
+
         try
         {
-            FileCacheDriveFree = di.AvailableFreeSpace;
+            var drive = DriveInfo.GetDrives()
+                .FirstOrDefault(d => _configService.Current.CacheFolder
+                    .StartsWith(d.Name, StringComparison.OrdinalIgnoreCase));
+
+            if (drive != null)
+                FileCacheDriveFree = drive.AvailableFreeSpace;
         }
         catch (Exception ex)
         {
-            Logger.LogWarning(ex, "Could not determine drive size for Storage Folder {folder}", _configService.Current.CacheFolder);
+            Logger.LogWarning(ex, "Could not determine drive size for storage folder {folder}", _configService.Current.CacheFolder);
         }
 
-        var files = Directory.EnumerateFiles(_configService.Current.CacheFolder).Select(f => new FileInfo(f))
-            .OrderBy(f => f.LastAccessTime).ToList();
-        FileCacheSize = files
-            .Sum(f =>
+        var cacheFolder = _configService.Current.CacheFolder;
+        var candidates = new List<CacheEvictionCandidate>();
+        long totalSize = 0;
+        totalSize += AddFolderCandidates(cacheFolder, candidates, token, isWine);
+        totalSize += AddFolderCandidates(Path.Combine(cacheFolder, "downscaled"), candidates, token, isWine);
+        totalSize += AddFolderCandidates(Path.Combine(cacheFolder, "decimated"), candidates, token, isWine);
+
+        FileCacheSize = totalSize;
+
+        var maxCacheInBytes = (long)(_configService.Current.MaxLocalCacheInGiB * 1024d * 1024d * 1024d);
+        if (FileCacheSize < maxCacheInBytes)
+            return;
+
+        var maxCacheBuffer = maxCacheInBytes * 0.05d;
+
+        candidates.Sort(static (a, b) => a.LastAccessTime.CompareTo(b.LastAccessTime));
+
+        var evictionTarget = maxCacheInBytes - (long)maxCacheBuffer;
+        var index = 0;
+        while (FileCacheSize > evictionTarget && index < candidates.Count)
         {
-                token.ThrowIfCancellationRequested();
+            var oldestFile = candidates[index];
 
             try
             {
-                    return _fileCompactor.GetFileSizeOnDisk(f, StorageisNTFS);
+                EvictCacheCandidate(oldestFile, cacheFolder);
+                FileCacheSize -= oldestFile.Size;
             }
-                catch
+            catch (Exception ex)
             {
-                    return 0;
+                Logger.LogTrace(ex, "Failed to delete old file {file}", oldestFile.FullPath);
             }
-            });
 
-        var maxCacheInBytes = (long)(_configService.Current.MaxLocalCacheInGiB * 1024d * 1024d * 1024d);
-
-        if (FileCacheSize < maxCacheInBytes) return;
-
-        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);
+            index++;
         }
     }
 
@@ -445,6 +484,114 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
         HaltScanLocks.Clear();
     }
 
+    private long AddFolderCandidates(string directory, List<CacheEvictionCandidate> candidates, CancellationToken token, bool isWine)
+    {
+        if (!Directory.Exists(directory))
+        {
+            return 0;
+        }
+
+        long totalSize = 0;
+        foreach (var path in Directory.EnumerateFiles(directory))
+        {
+            token.ThrowIfCancellationRequested();
+
+            try
+            {
+                var file = new FileInfo(path);
+                var size = GetFileSizeOnDisk(file, isWine);
+                totalSize += size;
+                candidates.Add(new CacheEvictionCandidate(file.FullName, size, file.LastAccessTime));
+            }
+            catch (Exception ex)
+            {
+                Logger.LogTrace(ex, "Error getting size for {file}", path);
+            }
+        }
+
+        return totalSize;
+    }
+
+    private long GetFileSizeOnDisk(FileInfo file, bool isWine)
+    {
+        if (isWine)
+        {
+            return file.Length;
+        }
+
+        try
+        {
+            return _fileCompactor.GetFileSizeOnDisk(file);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogTrace(ex, "GetFileSizeOnDisk failed for {file}, using fallback length", file.FullName);
+            return file.Length;
+        }
+    }
+
+    private void EvictCacheCandidate(CacheEvictionCandidate candidate, string cacheFolder)
+    {
+        if (TryGetCacheHashAndPrefixedPath(candidate.FullPath, cacheFolder, out var hash, out var prefixedPath))
+        {
+            _fileDbManager.RemoveHashedFile(hash, prefixedPath);
+        }
+
+        try
+        {
+            if (File.Exists(candidate.FullPath))
+            {
+                File.Delete(candidate.FullPath);
+            }
+        }
+        catch (Exception ex)
+        {
+            Logger.LogTrace(ex, "Failed to delete old file {file}", candidate.FullPath);
+        }
+    }
+
+    private static bool TryGetCacheHashAndPrefixedPath(string filePath, string cacheFolder, out string hash, out string prefixedPath)
+    {
+        hash = string.Empty;
+        prefixedPath = string.Empty;
+
+        if (string.IsNullOrEmpty(cacheFolder))
+        {
+            return false;
+        }
+
+        var fileName = Path.GetFileNameWithoutExtension(filePath);
+        if (string.IsNullOrEmpty(fileName) || !IsSha1Hash(fileName))
+        {
+            return false;
+        }
+
+        var relative = Path.GetRelativePath(cacheFolder, filePath)
+            .Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+        var sanitizedRelative = relative.TrimStart(Path.DirectorySeparatorChar);
+        prefixedPath = Path.Combine(FileCacheManager.CachePrefix, sanitizedRelative);
+        hash = fileName;
+        return true;
+    }
+
+    private static bool IsSha1Hash(string value)
+    {
+        if (value.Length != 40)
+        {
+            return false;
+        }
+
+        foreach (var ch in value)
+        {
+            if (!Uri.IsHexDigit(ch))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
     public void ResumeScan(string source)
     {
         if (!HaltScanLocks.ContainsKey(source)) HaltScanLocks[source] = 0;
@@ -456,12 +603,19 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
     protected override void Dispose(bool disposing)
     {
         base.Dispose(disposing);
-        _scanCancellationTokenSource?.Cancel();
+        // Disposing of file system watchers
         PenumbraWatcher?.Dispose();
         LightlessWatcher?.Dispose();
+
+        // Disposing of cancellation token sources
+        _scanCancellationTokenSource?.CancelDispose();
+        _scanCancellationTokenSource?.Dispose();
         _penumbraFswCts?.CancelDispose();
+        _penumbraFswCts?.Dispose();
         _lightlessFswCts?.CancelDispose();
+        _lightlessFswCts?.Dispose();
         _periodicCalculationTokenSource?.CancelDispose();
+        _periodicCalculationTokenSource?.Dispose();
     }
 
     private void FullFileScan(CancellationToken ct)
@@ -498,7 +652,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
                 [
                     .. Directory.GetFiles(folder, "*.*", SearchOption.AllDirectories)
                                             .AsParallel()
-                                            .Where(f => AllowedFileExtensions.Any(e => f.EndsWith(e, StringComparison.OrdinalIgnoreCase))
+                                            .Where(f => HasAllowedExtension(f)
                                                 && !f.Contains(@"\bg\", StringComparison.OrdinalIgnoreCase)
                                                 && !f.Contains(@"\bgcommon\", StringComparison.OrdinalIgnoreCase)
                                                 && !f.Contains(@"\ui\", StringComparison.OrdinalIgnoreCase)),
@@ -539,7 +693,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
 
         List<FileCacheEntity> entitiesToRemove = [];
         List<FileCacheEntity> entitiesToUpdate = [];
-        object sync = new();
+        Lock sync = new();
         Thread[] workerThreads = new Thread[threadCount];
 
         ConcurrentQueue<FileCacheEntity> fileCaches = new(_fileDbManager.GetAllFileCaches());
@@ -582,9 +736,16 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
                         }
                     }
                     catch (Exception ex)
+                    {
+                        if (workload != null)
                         {
                             Logger.LogWarning(ex, "Failed validating {path}", workload.ResolvedFilepath);
                         }
+                        else
+                        {
+                            Logger.LogWarning(ex, "Failed validating unknown workload");
+                        }
+                    }
                     Interlocked.Increment(ref _currentFileProgress);
                 }
 
@@ -612,7 +773,7 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
             return;
         }
 
-        if (entitiesToUpdate.Any() || entitiesToRemove.Any())
+        if (entitiesToUpdate.Count != 0 || entitiesToRemove.Count != 0)
         {
             foreach (var entity in entitiesToUpdate)
             {
@@ -637,17 +798,24 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
 
         if (ct.IsCancellationRequested) return;
 
-        // scan new files
-        if (allScannedFiles.Any(c => !c.Value))
+        var newFiles = allScannedFiles.Where(c => !c.Value).Select(c => c.Key).ToList();
+        foreach (var cachePath in newFiles)
         {
-            Parallel.ForEach(allScannedFiles.Where(c => !c.Value).Select(c => c.Key),
-                new ParallelOptions()
+            if (ct.IsCancellationRequested) break;
+            ProcessOne(cachePath);
+            Interlocked.Increment(ref _currentFileProgress);
+        }
+
+        Logger.LogTrace("Scanner added {count} new files to db", newFiles.Count);
+
+        void ProcessOne(string? cachePath)
         {
-                    MaxDegreeOfParallelism = threadCount,
-                    CancellationToken = ct
-                }, (cachePath) =>
+            if (_fileDbManager == null || _ipcManager?.Penumbra == null || cachePath == null)
             {
-                    if (ct.IsCancellationRequested) return;
+                Logger.LogTrace("Potential null in db: {isDbNull} penumbra: {isPenumbraNull} cachepath: {isPathNull}",
+                    _fileDbManager == null, _ipcManager?.Penumbra == null, cachePath == null);
+                return;
+            }
 
             if (!_ipcManager.Penumbra.APIAvailable)
             {
@@ -660,15 +828,14 @@ public sealed class CacheMonitor : DisposableMediatorSubscriberBase
                 var entry = _fileDbManager.CreateFileEntry(cachePath);
                 if (entry == null) _ = _fileDbManager.CreateCacheEntry(cachePath);
             }
+            catch (IOException ioex)
+            {
+                Logger.LogDebug(ioex, "File busy or locked: {file}", 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");

LightlessSync/FileCache/ExternalCompactionExecutor.cs

@@ -0,0 +1,241 @@
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+using System.IO.Pipes;
+using System.Text.Json;
+
+namespace LightlessSync.FileCache;
+
+internal sealed class ExternalCompactionExecutor : ICompactionExecutor, IDisposable
+{
+    private readonly ILogger<ExternalCompactionExecutor> _logger;
+    private readonly ICompactorContext _context;
+    private readonly TimeSpan _timeout = TimeSpan.FromMinutes(5);
+    private readonly string _pipeName;
+    private Process? _workerProcess;
+    private bool _disposed;
+    private readonly object _sync = new();
+
+    public ExternalCompactionExecutor(ILogger<ExternalCompactionExecutor> logger, ICompactorContext context)
+    {
+        _logger = logger;
+        _context = context;
+        _pipeName = $"LightlessCompactor-{Environment.ProcessId}";
+    }
+
+    public bool TryCompact(string filePath)
+    {
+        if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
+            return false;
+
+        if (!EnsureWorkerRunning())
+            return false;
+
+        try
+        {
+            var request = new CompactorRequest
+            {
+                Type = "compact",
+                Path = filePath
+            };
+
+            return SendRequest(request, out var response) && response?.Success == true;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "External compactor failed for {file}", filePath);
+            return false;
+        }
+    }
+
+    public void Dispose()
+    {
+        if (_disposed)
+            return;
+
+        _disposed = true;
+
+        try
+        {
+            SendRequest(new CompactorRequest { Type = "shutdown" }, out _);
+        }
+        catch
+        {
+            // ignore
+        }
+
+        lock (_sync)
+        {
+            if (_workerProcess is null)
+                return;
+
+            TryKill(_workerProcess);
+            _workerProcess.Dispose();
+            _workerProcess = null;
+        }
+    }
+
+    private bool EnsureWorkerRunning()
+    {
+        lock (_sync)
+        {
+            if (_workerProcess is { HasExited: false })
+                return true;
+
+            _workerProcess?.Dispose();
+            _workerProcess = null;
+
+            var workerPath = ResolveWorkerPath();
+            if (string.IsNullOrEmpty(workerPath))
+                return false;
+
+            var args = BuildArguments();
+            var startInfo = new ProcessStartInfo
+            {
+                FileName = workerPath,
+                Arguments = args,
+                CreateNoWindow = true,
+                UseShellExecute = false,
+                RedirectStandardOutput = true,
+                RedirectStandardError = true
+            };
+
+            var process = new Process { StartInfo = startInfo };
+            if (!process.Start())
+                return false;
+
+            TrySetLowPriority(process);
+            _ = DrainAsync(process.StandardOutput, "stdout");
+            _ = DrainAsync(process.StandardError, "stderr");
+
+            _workerProcess = process;
+            return true;
+        }
+    }
+
+    private bool SendRequest(CompactorRequest request, out CompactorResponse? response)
+    {
+        response = null;
+        using var pipe = new NamedPipeClientStream(".", _pipeName, PipeDirection.InOut, PipeOptions.Asynchronous);
+
+        try
+        {
+            pipe.Connect((int)_timeout.TotalMilliseconds);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Compactor pipe connection failed.");
+            return false;
+        }
+
+        using var writer = new StreamWriter(pipe) { AutoFlush = true };
+        using var reader = new StreamReader(pipe);
+
+        var payload = JsonSerializer.Serialize(request);
+        writer.WriteLine(payload);
+
+        var readTask = reader.ReadLineAsync();
+        if (!readTask.Wait(_timeout))
+        {
+            _logger.LogWarning("Compactor pipe timed out waiting for response.");
+            return false;
+        }
+
+        var line = readTask.Result;
+        if (string.IsNullOrWhiteSpace(line))
+            return false;
+
+        try
+        {
+            response = JsonSerializer.Deserialize<CompactorResponse>(line);
+            return response is not null;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to parse compactor response.");
+            return false;
+        }
+    }
+
+    private string? ResolveWorkerPath()
+    {
+        var baseDir = AppContext.BaseDirectory;
+        var exeName = OperatingSystem.IsWindows() || _context.IsWine
+            ? "LightlessCompactorWorker.exe"
+            : "LightlessCompactorWorker";
+        var path = Path.Combine(baseDir, exeName);
+        return File.Exists(path) ? path : null;
+    }
+
+    private string BuildArguments()
+    {
+        var args = new List<string> { "--pipe", Quote(_pipeName), "--parent", Environment.ProcessId.ToString() };
+        if (_context.IsWine)
+            args.Add("--wine");
+        return string.Join(' ', args);
+    }
+
+    private static string Quote(string value)
+    {
+        if (string.IsNullOrEmpty(value))
+            return "\"\"";
+
+        if (!value.Contains('"', StringComparison.Ordinal))
+            return "\"" + value + "\"";
+
+        return "\"" + value.Replace("\"", "\\\"", StringComparison.Ordinal) + "\"";
+    }
+
+    private static void TrySetLowPriority(Process process)
+    {
+        try
+        {
+            if (OperatingSystem.IsWindows())
+                process.PriorityClass = ProcessPriorityClass.BelowNormal;
+        }
+        catch
+        {
+            // ignore
+        }
+    }
+
+    private async Task DrainAsync(StreamReader reader, string label)
+    {
+        try
+        {
+            string? line;
+            while ((line = await reader.ReadLineAsync().ConfigureAwait(false)) != null)
+            {
+                if (_logger.IsEnabled(LogLevel.Trace))
+                    _logger.LogTrace("Compactor {label}: {line}", label, line);
+            }
+        }
+        catch
+        {
+            // ignore
+        }
+    }
+
+    private static void TryKill(Process process)
+    {
+        try
+        {
+            process.Kill(entireProcessTree: true);
+        }
+        catch
+        {
+            // ignore
+        }
+    }
+
+    private sealed class CompactorRequest
+    {
+        public string Type { get; init; } = "compact";
+        public string? Path { get; init; }
+    }
+
+    private sealed class CompactorResponse
+    {
+        public bool Success { get; init; }
+        public string? Error { get; init; }
+    }
+}

LightlessSync/FileCache/FileCacheEntity.cs

@@ -1,15 +1,23 @@
 #nullable disable
 
+using System.Text.Json.Serialization;
+
 namespace LightlessSync.FileCache;
 
 public class FileCacheEntity
 {
-    public FileCacheEntity(string hash, string path, string lastModifiedDateTicks, long? size = null, long? compressedSize = null)
+    [JsonConstructor]
+    public FileCacheEntity(
+        string hash,
+        string prefixedFilePath,
+        string lastModifiedDateTicks,
+        long? size = null,
+        long? compressedSize = null)
     {
         Size = size;
         CompressedSize = compressedSize;
         Hash = hash;
-        PrefixedFilePath = path;
+        PrefixedFilePath = prefixedFilePath;
         LastModifiedDateTicks = lastModifiedDateTicks;
     }
 
@@ -23,7 +31,5 @@ public class FileCacheEntity
     public long? Size { get; set; }
 
     public void SetResolvedFilePath(string filePath)
-    {
-        ResolvedFilepath = filePath.ToLowerInvariant().Replace("\\\\", "\\", StringComparison.Ordinal);
-    }
+        => ResolvedFilepath = filePath.ToLowerInvariant().Replace("\\\\", "\\", StringComparison.Ordinal);
 }

LightlessSync/FileCache/FileCompactor.cs

@@ -1,229 +0,0 @@
-using LightlessSync.LightlessConfiguration;
-using LightlessSync.Services;
-using Microsoft.Extensions.Logging;
-using System.Runtime.InteropServices;
-
-namespace LightlessSync.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 LightlessConfigService _lightlessConfigService;
-    private readonly DalamudUtilService _dalamudUtilService;
-
-    public FileCompactor(ILogger<FileCompactor> logger, LightlessConfigService lightlessConfigService, DalamudUtilService dalamudUtilService)
-    {
-        _clusterSizes = new(StringComparer.Ordinal);
-        _logger = logger;
-        _lightlessConfigService = lightlessConfigService;
-        _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(_lightlessConfigService.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 || !_lightlessConfigService.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);
-        }
-    }
-
-    private struct WOF_FILE_COMPRESSION_INFO_V1
-    {
-        public CompressionAlgorithm Algorithm;
-        public ulong Flags;
-    }
-}

LightlessSync/FileCache/FileState.cs

@@ -5,4 +5,5 @@ public enum FileState
     Valid,
     RequireUpdate,
     RequireDeletion,
+    RequireRehash
 }

LightlessSync/FileCache/PluginCompactorContext.cs

@@ -0,0 +1,20 @@
+using LightlessSync.LightlessConfiguration;
+using LightlessSync.Services;
+
+namespace LightlessSync.FileCache;
+
+internal sealed class PluginCompactorContext : ICompactorContext
+{
+    private readonly LightlessConfigService _configService;
+    private readonly DalamudUtilService _dalamudUtilService;
+
+    public PluginCompactorContext(LightlessConfigService configService, DalamudUtilService dalamudUtilService)
+    {
+        _configService = configService;
+        _dalamudUtilService = dalamudUtilService;
+    }
+
+    public bool UseCompactor => _configService.Current.UseCompactor;
+    public string CacheFolder => _configService.Current.CacheFolder;
+    public bool IsWine => _dalamudUtilService.IsWine;
+}

LightlessSync/FileCache/TransientResourceManager.cs

@@ -3,11 +3,14 @@ using LightlessSync.LightlessConfiguration;
 using LightlessSync.LightlessConfiguration.Configurations;
 using LightlessSync.PlayerData.Data;
 using LightlessSync.PlayerData.Handlers;
+using LightlessSync.PlayerData.Factories;
 using LightlessSync.Services;
+using LightlessSync.Services.ActorTracking;
 using LightlessSync.Services.Mediator;
 using LightlessSync.Utils;
 using Microsoft.Extensions.Logging;
 using System.Collections.Concurrent;
+using DalamudObjectKind = Dalamud.Game.ClientState.Objects.Enums.ObjectKind;
 
 namespace LightlessSync.FileCache;
 
@@ -17,33 +20,53 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
     private readonly HashSet<string> _cachedHandledPaths = new(StringComparer.Ordinal);
     private readonly TransientConfigService _configurationService;
     private readonly DalamudUtilService _dalamudUtil;
-    private readonly string[] _handledFileTypes = ["tmb", "pap", "avfx", "atex", "sklb", "eid", "phyb", "scd", "skp", "shpk"];
+    private readonly ActorObjectService _actorObjectService;
+    private readonly GameObjectHandlerFactory _gameObjectHandlerFactory;
+    private readonly object _ownedHandlerLock = new();
+    private readonly string[] _handledFileTypes = ["tmb", "pap", "avfx", "atex", "sklb", "eid", "phyb", "scd", "skp", "shpk", "kdb"];
     private readonly string[] _handledRecordingFileTypes = ["tex", "mdl", "mtrl"];
     private readonly HashSet<GameObjectHandler> _playerRelatedPointers = [];
-    private ConcurrentDictionary<IntPtr, ObjectKind> _cachedFrameAddresses = [];
+    private readonly object _playerRelatedLock = new();
+    private readonly ConcurrentDictionary<nint, GameObjectHandler> _playerRelatedByAddress = new();
+    private readonly Dictionary<nint, GameObjectHandler> _ownedHandlers = new();
+    private ConcurrentDictionary<nint, ObjectKind> _cachedFrameAddresses = new();
     private ConcurrentDictionary<ObjectKind, HashSet<string>>? _semiTransientResources = null;
     private uint _lastClassJobId = uint.MaxValue;
     public bool IsTransientRecording { get; private set; } = false;
 
     public TransientResourceManager(ILogger<TransientResourceManager> logger, TransientConfigService configurationService,
-            DalamudUtilService dalamudUtil, LightlessMediator mediator) : base(logger, mediator)
+            DalamudUtilService dalamudUtil, LightlessMediator mediator, ActorObjectService actorObjectService, GameObjectHandlerFactory gameObjectHandlerFactory) : base(logger, mediator)
     {
         _configurationService = configurationService;
         _dalamudUtil = dalamudUtil;
-
+        _actorObjectService = actorObjectService;
+        _gameObjectHandlerFactory = gameObjectHandlerFactory;
         Mediator.Subscribe<PenumbraResourceLoadMessage>(this, Manager_PenumbraResourceLoadEvent);
+        Mediator.Subscribe<ActorTrackedMessage>(this, msg => HandleActorTracked(msg.Descriptor));
+        Mediator.Subscribe<ActorUntrackedMessage>(this, msg => HandleActorUntracked(msg.Descriptor));
         Mediator.Subscribe<PenumbraModSettingChangedMessage>(this, (_) => Manager_PenumbraModSettingChanged());
         Mediator.Subscribe<PriorityFrameworkUpdateMessage>(this, (_) => DalamudUtil_FrameworkUpdate());
         Mediator.Subscribe<GameObjectHandlerCreatedMessage>(this, (msg) =>
         {
             if (!msg.OwnedObject) return;
+            lock (_playerRelatedLock)
+            {
                 _playerRelatedPointers.Add(msg.GameObjectHandler);
+            }
         });
         Mediator.Subscribe<GameObjectHandlerDestroyedMessage>(this, (msg) =>
         {
             if (!msg.OwnedObject) return;
+            lock (_playerRelatedLock)
+            {
                 _playerRelatedPointers.Remove(msg.GameObjectHandler);
+            }
         });
+
+        foreach (var descriptor in _actorObjectService.ObjectDescriptors)
+        {
+            HandleActorTracked(descriptor);
+        }
     }
 
     private TransientConfig.TransientPlayerConfig PlayerConfig
@@ -59,7 +82,7 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
         }
     }
 
-    private string PlayerPersistentDataKey => _dalamudUtil.GetPlayerNameAsync().GetAwaiter().GetResult() + "_" + _dalamudUtil.GetHomeWorldIdAsync().GetAwaiter().GetResult();
+    private string PlayerPersistentDataKey => _dalamudUtil.GetPlayerName() + "_" + _dalamudUtil.GetHomeWorldId();
     private ConcurrentDictionary<ObjectKind, HashSet<string>> SemiTransientResources
     {
         get
@@ -68,9 +91,12 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
             {
                 _semiTransientResources = new();
                 PlayerConfig.JobSpecificCache.TryGetValue(_dalamudUtil.ClassJobId, out var jobSpecificData);
-                _semiTransientResources[ObjectKind.Player] = PlayerConfig.GlobalPersistentCache.Concat(jobSpecificData ?? []).ToHashSet(StringComparer.Ordinal);
+                _semiTransientResources[ObjectKind.Player] = PlayerConfig.GlobalPersistentCache.Concat(jobSpecificData ?? [])
+                    .ToHashSet(StringComparer.OrdinalIgnoreCase);
                 PlayerConfig.JobSpecificPetCache.TryGetValue(_dalamudUtil.ClassJobId, out var petSpecificData);
-                _semiTransientResources[ObjectKind.Pet] = [.. petSpecificData ?? []];
+                _semiTransientResources[ObjectKind.Pet] = new HashSet<string>(
+                    petSpecificData ?? [],
+                    StringComparer.OrdinalIgnoreCase);
             }
 
             return _semiTransientResources;
@@ -108,14 +134,14 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
     {
         SemiTransientResources.TryGetValue(objectKind, out var result);
 
-        return result ?? new HashSet<string>(StringComparer.Ordinal);
+        return result ?? new HashSet<string>(StringComparer.OrdinalIgnoreCase);
     }
 
     public void PersistTransientResources(ObjectKind objectKind)
     {
         if (!SemiTransientResources.TryGetValue(objectKind, out HashSet<string>? semiTransientResources))
         {
-            SemiTransientResources[objectKind] = semiTransientResources = new(StringComparer.Ordinal);
+            SemiTransientResources[objectKind] = semiTransientResources = new(StringComparer.OrdinalIgnoreCase);
         }
 
         if (!TransientResources.TryGetValue(objectKind, out var resources))
@@ -123,13 +149,22 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
             return;
         }
 
-        var transientResources = resources.ToList();
+        List<string> transientResources;
+        lock (resources)
+        {
+            transientResources = resources.ToList();
+        }
+
         Logger.LogDebug("Persisting {count} transient resources", transientResources.Count);
-        List<string> newlyAddedGamePaths = resources.Except(semiTransientResources, StringComparer.Ordinal).ToList();
+        List<string> newlyAddedGamePaths;
+        lock (semiTransientResources)
+        {
+            newlyAddedGamePaths = transientResources.Except(semiTransientResources, StringComparer.OrdinalIgnoreCase).ToList();
             foreach (var gamePath in transientResources)
             {
                 semiTransientResources.Add(gamePath);
             }
+        }
 
         bool saveConfig = false;
         if (objectKind == ObjectKind.Player && newlyAddedGamePaths.Count != 0)
@@ -161,17 +196,21 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
             _configurationService.Save();
         }
 
-        TransientResources[objectKind].Clear();
+        lock (resources)
+        {
+            resources.Clear();
+        }
     }
 
     public void RemoveTransientResource(ObjectKind objectKind, string path)
     {
+        var normalizedPath = NormalizeGamePath(path);
         if (SemiTransientResources.TryGetValue(objectKind, out var resources))
         {
-            resources.RemoveWhere(f => string.Equals(path, f, StringComparison.Ordinal));
+            resources.Remove(normalizedPath);
             if (objectKind == ObjectKind.Player)
             {
-                PlayerConfig.RemovePath(path, objectKind);
+                PlayerConfig.RemovePath(normalizedPath, objectKind);
                 Logger.LogTrace("Saving transient.json from {method}", nameof(RemoveTransientResource));
                 _configurationService.Save();
             }
@@ -180,16 +219,17 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
 
     internal bool AddTransientResource(ObjectKind objectKind, string item)
     {
-        if (SemiTransientResources.TryGetValue(objectKind, out var semiTransient) && semiTransient != null && semiTransient.Contains(item))
+        var normalizedItem = NormalizeGamePath(item);
+        if (SemiTransientResources.TryGetValue(objectKind, out var semiTransient) && semiTransient != null && semiTransient.Contains(normalizedItem))
             return false;
 
         if (!TransientResources.TryGetValue(objectKind, out HashSet<string>? transientResource))
         {
-            transientResource = new HashSet<string>(StringComparer.Ordinal);
+            transientResource = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             TransientResources[objectKind] = transientResource;
         }
 
-        return transientResource.Add(item.ToLowerInvariant());
+        return transientResource.Add(normalizedItem);
     }
 
     internal void ClearTransientPaths(ObjectKind objectKind, List<string> list)
@@ -241,17 +281,66 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
 
         TransientResources.Clear();
         SemiTransientResources.Clear();
+
+        lock (_ownedHandlerLock)
+        {
+            foreach (var handler in _ownedHandlers.Values)
+            {
+                handler.Dispose();
+            }
+            _ownedHandlers.Clear();
+        }
     }
 
     private void DalamudUtil_FrameworkUpdate()
     {
-        _cachedFrameAddresses = new(_playerRelatedPointers.Where(k => k.Address != nint.Zero).ToDictionary(c => c.Address, c => c.ObjectKind));
+        _ = Task.Run(() => RefreshPlayerRelatedAddressMap());
+
         lock (_cacheAdditionLock)
         {
             _cachedHandledPaths.Clear();
         }
 
         if (_lastClassJobId != _dalamudUtil.ClassJobId)
+        {
+            UpdateClassJobCache();
+        }
+
+        CleanupAbsentObjects();
+    }
+
+    private void RefreshPlayerRelatedAddressMap()
+    {
+        var tempMap = new ConcurrentDictionary<nint, GameObjectHandler>();
+        var updatedFrameAddresses = new ConcurrentDictionary<nint, ObjectKind>();
+
+        lock (_playerRelatedLock)
+        {
+            foreach (var handler in _playerRelatedPointers)
+            {
+                var address = (nint)handler.Address;
+                if (address != nint.Zero)
+                {
+                    tempMap[address] = handler;
+                    updatedFrameAddresses[address] = handler.ObjectKind;
+                }
+            }
+        }
+
+        _playerRelatedByAddress.Clear();
+        foreach (var kvp in tempMap)
+        {
+            _playerRelatedByAddress[kvp.Key] = kvp.Value;
+        }
+
+        _cachedFrameAddresses.Clear();
+        foreach (var kvp in updatedFrameAddresses)
+        {
+            _cachedFrameAddresses[kvp.Key] = kvp.Value;
+        }
+    }
+
+    private void UpdateClassJobCache()
     {
         _lastClassJobId = _dalamudUtil.ClassJobId;
         if (SemiTransientResources.TryGetValue(ObjectKind.Pet, out HashSet<string>? value))
@@ -259,16 +348,22 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
             value?.Clear();
         }
 
-            // reload config for current new classjob
         PlayerConfig.JobSpecificCache.TryGetValue(_dalamudUtil.ClassJobId, out var jobSpecificData);
-            SemiTransientResources[ObjectKind.Player] = PlayerConfig.GlobalPersistentCache.Concat(jobSpecificData ?? []).ToHashSet(StringComparer.OrdinalIgnoreCase);
+        SemiTransientResources[ObjectKind.Player] = PlayerConfig.GlobalPersistentCache
+            .Concat(jobSpecificData ?? [])
+            .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
         PlayerConfig.JobSpecificPetCache.TryGetValue(_dalamudUtil.ClassJobId, out var petSpecificData);
-            SemiTransientResources[ObjectKind.Pet] = [.. petSpecificData ?? []];
+        SemiTransientResources[ObjectKind.Pet] = new HashSet<string>(
+            petSpecificData ?? [],
+            StringComparer.OrdinalIgnoreCase);
     }
 
-        foreach (var kind in Enum.GetValues(typeof(ObjectKind)))
+    private void CleanupAbsentObjects()
     {
-            if (!_cachedFrameAddresses.Any(k => k.Value == (ObjectKind)kind) && TransientResources.Remove((ObjectKind)kind, out _))
+        foreach (var kind in Enum.GetValues(typeof(ObjectKind)).Cast<ObjectKind>())
+        {
+            if (!_cachedFrameAddresses.Any(k => k.Value == kind) && TransientResources.Remove(kind, out _))
             {
                 Logger.LogDebug("Object not present anymore: {kind}", kind.ToString());
             }
@@ -280,10 +375,13 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
         _ = Task.Run(() =>
         {
             Logger.LogDebug("Penumbra Mod Settings changed, verifying SemiTransientResources");
+            lock (_playerRelatedLock)
+            {
                 foreach (var item in _playerRelatedPointers)
                 {
                     Mediator.Publish(new TransientResourceChangedMessage(item.Address));
                 }
+            }
         });
     }
 
@@ -292,6 +390,134 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
         _semiTransientResources = null;
     }
 
+    private void HandleActorTracked(ActorObjectService.ActorDescriptor descriptor)
+    {
+        if (descriptor.IsInGpose)
+            return;
+
+        if (descriptor.OwnedKind is not ObjectKind ownedKind)
+            return;
+
+        if (Logger.IsEnabled(LogLevel.Debug))
+        {
+            Logger.LogDebug("ActorObject tracked: {kind} addr={address:X} name={name}", ownedKind, descriptor.Address, descriptor.Name);
+        }
+
+        _cachedFrameAddresses[descriptor.Address] = ownedKind;
+
+        lock (_ownedHandlerLock)
+        {
+            if (_ownedHandlers.ContainsKey(descriptor.Address))
+                return;
+
+            _ = CreateOwnedHandlerAsync(descriptor, ownedKind);
+        }
+    }
+
+    private void HandleActorUntracked(ActorObjectService.ActorDescriptor descriptor)
+    {
+        if (Logger.IsEnabled(LogLevel.Debug))
+        {
+            var kindLabel = descriptor.OwnedKind?.ToString()
+                ?? (descriptor.ObjectKind == DalamudObjectKind.Player ? ObjectKind.Player.ToString() : "<none>");
+            Logger.LogDebug("ActorObject untracked: addr={address:X} name={name} kind={kind}", descriptor.Address, descriptor.Name, kindLabel);
+        }
+
+        _cachedFrameAddresses.TryRemove(descriptor.Address, out _);
+
+        if (descriptor.OwnedKind is not ObjectKind)
+            return;
+
+        lock (_ownedHandlerLock)
+        {
+            if (_ownedHandlers.Remove(descriptor.Address, out var handler))
+            {
+                handler.Dispose();
+            }
+        }
+    }
+
+    private async Task CreateOwnedHandlerAsync(ActorObjectService.ActorDescriptor descriptor, ObjectKind kind)
+    {
+        try
+        {
+            var handler = await _gameObjectHandlerFactory.Create(
+                kind,
+                () =>
+                {
+                    if (!string.IsNullOrEmpty(descriptor.HashedContentId) &&
+                        _actorObjectService.TryGetValidatedActorByHash(descriptor.HashedContentId, out var current) &&
+                        current.OwnedKind == kind)
+                    {
+                        return current.Address;
+                    }
+
+                    return descriptor.Address;
+                },
+                true).ConfigureAwait(false);
+
+            if (handler.Address == IntPtr.Zero)
+            {
+                handler.Dispose();
+                return;
+            }
+
+            lock (_ownedHandlerLock)
+            {
+                if (!_cachedFrameAddresses.ContainsKey(descriptor.Address))
+                {
+                    Logger.LogDebug("ActorObject handler discarded (stale): addr={address:X}", descriptor.Address);
+                    handler.Dispose();
+                    return;
+                }
+
+                _ownedHandlers[descriptor.Address] = handler;
+            }
+
+            Logger.LogDebug("ActorObject handler created: {kind} addr={address:X}", kind, descriptor.Address);
+        }
+        catch (Exception ex)
+        {
+            Logger.LogError(ex, "Failed to create owned handler for {kind} at {address:X}", kind, descriptor.Address);
+        }
+    }
+
+    private static string NormalizeGamePath(string path)
+    {
+        if (string.IsNullOrEmpty(path))
+            return string.Empty;
+
+        return path.Replace("\\", "/", StringComparison.Ordinal).ToLowerInvariant();
+    }
+
+    private static string NormalizeFilePath(string path)
+    {
+        if (string.IsNullOrEmpty(path))
+            return string.Empty;
+
+        if (path.StartsWith("|", StringComparison.Ordinal))
+        {
+            var lastPipe = path.LastIndexOf('|');
+            if (lastPipe >= 0 && lastPipe + 1 < path.Length)
+            {
+                path = path[(lastPipe + 1)..];
+            }
+        }
+
+        return NormalizeGamePath(path);
+    }
+
+    private static bool HasHandledFileType(string gamePath, string[] handledTypes)
+    {
+        for (var i = 0; i < handledTypes.Length; i++)
+        {
+            if (gamePath.EndsWith(handledTypes[i], StringComparison.Ordinal))
+                return true;
+        }
+
+        return false;
+    }
+
     private void Manager_PenumbraResourceLoadEvent(PenumbraResourceLoadMessage msg)
     {
         var gamePath = msg.GamePath.ToLowerInvariant();
@@ -350,11 +576,12 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
             TransientResources[objectKind] = transientResources;
         }
 
-        var owner = _playerRelatedPointers.FirstOrDefault(f => f.Address == gameObjectAddress);
+        _playerRelatedByAddress.TryGetValue(gameObjectAddress, out var owner);
         bool alreadyTransient = false;
 
         bool transientContains = transientResources.Contains(replacedGamePath);
-        bool semiTransientContains = SemiTransientResources.SelectMany(k => k.Value).Any(f => string.Equals(f, gamePath, StringComparison.OrdinalIgnoreCase));
+        bool semiTransientContains = SemiTransientResources.SelectMany(k => k.Value)
+            .Any(f => string.Equals(f, gamePath, StringComparison.OrdinalIgnoreCase));
         if (transientContains || semiTransientContains)
         {
             if (!IsTransientRecording)
@@ -383,21 +610,30 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
 
     private void SendTransients(nint gameObject, ObjectKind objectKind)
     {
-        _ = Task.Run(async () =>
-        {
-            _sendTransientCts?.Cancel();
-            _sendTransientCts?.Dispose();
+        _sendTransientCts.Cancel();
         _sendTransientCts = new();
         var token = _sendTransientCts.Token;
-            await Task.Delay(TimeSpan.FromSeconds(5), token).ConfigureAwait(false);
-            foreach (var kvp in TransientResources)
+
+        _ = Task.Run(async () =>
         {
+            try
+            {
+                await Task.Delay(TimeSpan.FromSeconds(5), token).ConfigureAwait(false);
+
                 if (TransientResources.TryGetValue(objectKind, out var values) && values.Any())
                 {
                     Logger.LogTrace("Sending Transients for {kind}", objectKind);
                     Mediator.Publish(new TransientResourceChangedMessage(gameObject));
                 }
             }
+            catch (TaskCanceledException)
+            {
+
+            }
+            catch (System.OperationCanceledException)
+            {
+
+            }
         });
     }
 
@@ -440,7 +676,7 @@ public sealed class TransientResourceManager : DisposableMediatorSubscriberBase
             if (!item.AddTransient || item.AlreadyTransient) continue;
             if (!TransientResources.TryGetValue(item.Owner.ObjectKind, out var transient))
             {
-                TransientResources[item.Owner.ObjectKind] = transient = [];
+                TransientResources[item.Owner.ObjectKind] = transient = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             }
 
             Logger.LogTrace("Adding recorded: {gamePath} => {filePath}", item.GamePath, item.FilePath);

LightlessSync/Interop/BlockedCharacterHandler.cs

@@ -1,4 +1,5 @@
 using Dalamud.Plugin.Services;
+using Dalamud.Game.ClientState.Objects.SubKinds;
 using FFXIVClientStructs.FFXIV.Client.Game.Character;
 using FFXIVClientStructs.FFXIV.Client.UI.Info;
 using Microsoft.Extensions.Logging;
@@ -11,24 +12,35 @@ public unsafe class BlockedCharacterHandler
     private readonly Dictionary<CharaData, bool> _blockedCharacterCache = new();
 
     private readonly ILogger<BlockedCharacterHandler> _logger;
+    private readonly IObjectTable _objectTable;
 
-    public BlockedCharacterHandler(ILogger<BlockedCharacterHandler> logger, IGameInteropProvider gameInteropProvider)
+    public BlockedCharacterHandler(ILogger<BlockedCharacterHandler> logger, IGameInteropProvider gameInteropProvider, IObjectTable objectTable)
     {
         gameInteropProvider.InitializeFromAttributes(this);
         _logger = logger;
+        _objectTable = objectTable;
     }
 
-    private static CharaData GetIdsFromPlayerPointer(nint ptr)
+    private CharaData? TryGetIdsFromPlayerPointer(nint ptr, ushort objectIndex)
     {
-        if (ptr == nint.Zero) return new(0, 0);
-        var castChar = ((BattleChara*)ptr);
+        if (ptr == nint.Zero || objectIndex >= 200)
+            return null;
+
+        var obj = _objectTable[objectIndex];
+        if (obj is not IPlayerCharacter player || player.Address != ptr)
+            return null;
+
+        var castChar = (BattleChara*)player.Address;
         return new(castChar->Character.AccountId, castChar->Character.ContentId);
     }
 
-    public bool IsCharacterBlocked(nint ptr, out bool firstTime)
+    public bool IsCharacterBlocked(nint ptr, ushort objectIndex, out bool firstTime)
     {
         firstTime = false;
-        var combined = GetIdsFromPlayerPointer(ptr);
+        var combined = TryGetIdsFromPlayerPointer(ptr, objectIndex);
+        if (combined == null)
+            return false;
+
         if (_blockedCharacterCache.TryGetValue(combined, out var isBlocked))
             return isBlocked;
 

LightlessSync/Interop/DalamudLogger.cs

@@ -20,7 +20,10 @@ internal sealed class DalamudLogger : ILogger
         _hasModifiedGameFiles = hasModifiedGameFiles;
     }
 
-    public IDisposable BeginScope<TState>(TState state) => default!;
+    IDisposable? ILogger.BeginScope<TState>(TState state)
+    {
+        return default!;
+    }
 
     public bool IsEnabled(LogLevel logLevel)
     {

LightlessSync/Interop/InteropModel/Enums/ResidentialAetheryteKind.cs

@@ -0,0 +1,11 @@
+namespace Lifestream.Enums;
+
+public enum ResidentialAetheryteKind
+{
+    None = -1,
+    Uldah = 9,
+    Gridania = 2,
+    Limsa = 8,
+    Foundation = 70,
+    Kugane = 111,
+}

LightlessSync/Interop/InteropModel/GlobalModels.cs

@@ -0,0 +1 @@
+global using AddressBookEntryTuple = (string Name, int World, int City, int Ward, int PropertyType, int Plot, int Apartment, bool ApartmentSubdivision, bool AliasEnabled, string Alias);

LightlessSync/Interop/Ipc/Framework/IpcFramework.cs

@@ -0,0 +1,196 @@
+using Dalamud.Plugin;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Linq;
+
+namespace LightlessSync.Interop.Ipc.Framework;
+
+public enum IpcConnectionState
+{
+    Unknown = 0,
+    MissingPlugin = 1,
+    VersionMismatch = 2,
+    PluginDisabled = 3,
+    NotReady = 4,
+    Available = 5,
+    Error = 6,
+}
+
+public sealed record IpcServiceDescriptor(string InternalName, string DisplayName, Version MinimumVersion)
+{
+    public override string ToString()
+        => $"{DisplayName} (>= {MinimumVersion})";
+}
+
+public interface IIpcService : IDisposable
+{
+    IpcServiceDescriptor Descriptor { get; }
+    IpcConnectionState State { get; }
+    IDalamudPluginInterface PluginInterface { get; }
+    bool APIAvailable { get; }
+    void CheckAPI();
+}
+
+public interface IIpcInterop : IDisposable
+{
+    string Name { get; }
+    void OnConnectionStateChanged(IpcConnectionState state);
+}
+
+public abstract class IpcInteropBase : IIpcInterop
+{
+    protected IpcInteropBase(ILogger logger)
+    {
+        Logger = logger;
+    }
+
+    protected ILogger Logger { get; }
+
+    protected IpcConnectionState State { get; private set; } = IpcConnectionState.Unknown;
+
+    protected bool IsAvailable => State == IpcConnectionState.Available;
+
+    public abstract string Name { get; }
+
+    public void OnConnectionStateChanged(IpcConnectionState state)
+    {
+        if (State == state)
+        {
+            return;
+        }
+
+        var previous = State;
+        State = state;
+        HandleStateChange(previous, state);
+    }
+
+    protected abstract void HandleStateChange(IpcConnectionState previous, IpcConnectionState current);
+
+    public virtual void Dispose()
+    {
+    }
+}
+
+public abstract class IpcServiceBase : DisposableMediatorSubscriberBase, IIpcService
+{
+    private readonly List<IIpcInterop> _interops = new();
+
+    protected IpcServiceBase(
+        ILogger logger,
+        LightlessMediator mediator,
+        IDalamudPluginInterface pluginInterface,
+        IpcServiceDescriptor descriptor) : base(logger, mediator)
+    {
+        PluginInterface = pluginInterface;
+        Descriptor = descriptor;
+    }
+
+    protected IDalamudPluginInterface PluginInterface { get; }
+
+    IDalamudPluginInterface IIpcService.PluginInterface => PluginInterface;
+
+    protected IpcServiceDescriptor Descriptor { get; }
+
+    IpcServiceDescriptor IIpcService.Descriptor => Descriptor;
+
+    public IpcConnectionState State { get; private set; } = IpcConnectionState.Unknown;
+
+    public bool APIAvailable => State == IpcConnectionState.Available;
+
+    public virtual void CheckAPI()
+    {
+        var newState = EvaluateState();
+        UpdateState(newState);
+    }
+
+    protected virtual IpcConnectionState EvaluateState()
+    {
+        try
+        {
+            var plugin = PluginInterface.InstalledPlugins
+                .Where(p => string.Equals(p.InternalName, Descriptor.InternalName, StringComparison.OrdinalIgnoreCase))
+                .OrderByDescending(p => p.IsLoaded)
+                .FirstOrDefault();
+
+            if (plugin == null)
+            {
+                return IpcConnectionState.MissingPlugin;
+            }
+
+            if (plugin.Version < Descriptor.MinimumVersion)
+            {
+                return IpcConnectionState.VersionMismatch;
+            }
+
+            if (!IsPluginEnabled(plugin))
+            {
+                return IpcConnectionState.PluginDisabled;
+            }
+
+            if (!IsPluginReady())
+            {
+                return IpcConnectionState.NotReady;
+            }
+
+            return IpcConnectionState.Available;
+        }
+        catch (Exception ex)
+        {
+            Logger.LogDebug(ex, "Failed to evaluate IPC state for {Service}", Descriptor.DisplayName);
+            return IpcConnectionState.Error;
+        }
+    }
+
+    protected virtual bool IsPluginEnabled(IExposedPlugin plugin)
+        => plugin.IsLoaded;
+
+    protected virtual bool IsPluginReady()
+        => true;
+
+    protected TInterop RegisterInterop<TInterop>(TInterop interop)
+        where TInterop : IIpcInterop
+    {
+        _interops.Add(interop);
+        interop.OnConnectionStateChanged(State);
+        return interop;
+    }
+
+    private void UpdateState(IpcConnectionState newState)
+    {
+        if (State == newState)
+        {
+            return;
+        }
+
+        var previous = State;
+        State = newState;
+        OnConnectionStateChanged(previous, newState);
+
+        foreach (var interop in _interops)
+        {
+            interop.OnConnectionStateChanged(newState);
+        }
+    }
+
+    protected virtual void OnConnectionStateChanged(IpcConnectionState previous, IpcConnectionState current)
+    {
+        Logger.LogTrace("{Service} IPC state transitioned from {Previous} to {Current}", Descriptor.DisplayName, previous, current);
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
+
+        if (!disposing)
+        {
+            return;
+        }
+
+        for (var i = _interops.Count - 1; i >= 0; --i)
+        {
+            _interops[i].Dispose();
+        }
+
+        _interops.Clear();
+    }
+}

LightlessSync/Interop/Ipc/IIpcCaller.cs

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

LightlessSync/Interop/Ipc/IpcCallerBrio.cs

@@ -1,69 +1,63 @@
-using Dalamud.Game.ClientState.Objects.Types;
+using Brio.API;
+using Dalamud.Game.ClientState.Objects.Types;
 using Dalamud.Plugin;
-using Dalamud.Plugin.Ipc;
 using LightlessSync.API.Dto.CharaData;
+using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.Services;
+using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
 using System.Numerics;
 using System.Text.Json.Nodes;
 
 namespace LightlessSync.Interop.Ipc;
 
-public sealed class IpcCallerBrio : IIpcCaller
+public sealed class IpcCallerBrio : IpcServiceBase
 {
+    private static readonly IpcServiceDescriptor BrioDescriptor = new("Brio", "Brio", new Version(0, 0, 0, 0));
+
     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;
+    private readonly ApiVersion _apiVersion;
 
+    private readonly SpawnActor _spawnActor;
+    private readonly DespawnActor _despawnActor;
+    private readonly SetModelTransform _setModelTransform;
+    private readonly GetModelTransform _getModelTransform;
 
-    public bool APIAvailable { get; private set; }
+    private readonly GetPoseAsJson _getPoseAsJson;
+    private readonly LoadPoseFromJson _setPoseFromJson;
+
+    private readonly FreezeActor _freezeActor;
+    private readonly FreezePhysics _freezePhysics;
 
     public IpcCallerBrio(ILogger<IpcCallerBrio> logger, IDalamudPluginInterface dalamudPluginInterface,
-        DalamudUtilService dalamudUtilService)
+        DalamudUtilService dalamudUtilService, LightlessMediator mediator) : base(logger, mediator, dalamudPluginInterface, BrioDescriptor)
     {
         _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");
+        _apiVersion = new ApiVersion(dalamudPluginInterface);
+        _spawnActor = new SpawnActor(dalamudPluginInterface);
+        _despawnActor = new DespawnActor(dalamudPluginInterface);
+
+        _setModelTransform = new SetModelTransform(dalamudPluginInterface);
+        _getModelTransform = new GetModelTransform(dalamudPluginInterface);
+
+        _getPoseAsJson = new GetPoseAsJson(dalamudPluginInterface);
+        _setPoseFromJson = new LoadPoseFromJson(dalamudPluginInterface);
+
+        _freezeActor = new FreezeActor(dalamudPluginInterface);
+        _freezePhysics = new FreezePhysics(dalamudPluginInterface);
 
         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);
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _spawnActor.Invoke(Brio.API.Enums.SpawnFlags.Default, true)).ConfigureAwait(false);
     }
 
     public async Task<bool> DespawnActorAsync(nint address)
@@ -72,7 +66,7 @@ public sealed class IpcCallerBrio : IIpcCaller
         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);
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _despawnActor.Invoke(gameObject)).ConfigureAwait(false);
     }
 
     public async Task<bool> ApplyTransformAsync(nint address, WorldData data)
@@ -82,7 +76,7 @@ public sealed class IpcCallerBrio : IIpcCaller
         if (gameObject == null) return false;
         _logger.LogDebug("Applying Transform to Actor {actor}", gameObject.Name.TextValue);
 
-        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioSetModelTransform.InvokeFunc(gameObject,
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _setModelTransform.Invoke(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);
@@ -93,8 +87,7 @@ public sealed class IpcCallerBrio : IIpcCaller
         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);
-        //_logger.LogDebug("Getting Transform from Actor {actor}", gameObject.Name.TextValue);
+        var data = await _dalamudUtilService.RunOnFrameworkThread(() => _getModelTransform.Invoke(gameObject)).ConfigureAwait(false);
 
         return new WorldData()
         {
@@ -118,7 +111,7 @@ public sealed class IpcCallerBrio : IIpcCaller
         if (gameObject == null) return null;
         _logger.LogDebug("Getting Pose from Actor {actor}", gameObject.Name.TextValue);
 
-        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioGetPoseAsJson.InvokeFunc(gameObject)).ConfigureAwait(false);
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _getPoseAsJson.Invoke(gameObject)).ConfigureAwait(false);
     }
 
     public async Task<bool> SetPoseAsync(nint address, string pose)
@@ -129,18 +122,41 @@ public sealed class IpcCallerBrio : IIpcCaller
         _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);
+        var currentPose = await _dalamudUtilService.RunOnFrameworkThread(() => _getPoseAsJson.Invoke(gameObject)).ConfigureAwait(false);
         applicablePose["ModelDifference"] = JsonNode.Parse(JsonNode.Parse(currentPose)!["ModelDifference"]!.ToJsonString());
 
         await _dalamudUtilService.RunOnFrameworkThread(() =>
         {
-            _brioFreezeActor.InvokeFunc(gameObject);
-            _brioFreezePhysics.InvokeFunc();
+            _freezeActor.Invoke(gameObject);
+            _freezePhysics.Invoke();
         }).ConfigureAwait(false);
-        return await _dalamudUtilService.RunOnFrameworkThread(() => _brioSetPoseFromJson.InvokeFunc(gameObject, applicablePose.ToJsonString(), false)).ConfigureAwait(false);
+        return await _dalamudUtilService.RunOnFrameworkThread(() => _setPoseFromJson.Invoke(gameObject, applicablePose.ToJsonString(), false)).ConfigureAwait(false);
     }
 
-    public void Dispose()
+    protected override IpcConnectionState EvaluateState()
     {
+        var state = base.EvaluateState();
+        if (state != IpcConnectionState.Available)
+        {
+            return state;
+        }
+
+        try
+        {
+            var version = _apiVersion.Invoke();
+            return version.Breaking == 3 && version.Feature >= 0
+                ? IpcConnectionState.Available
+                : IpcConnectionState.VersionMismatch;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to query Brio IPC version");
+            return IpcConnectionState.Error;
+        }
+    }
+
+    protected override void Dispose(bool disposing)
+    {
+        base.Dispose(disposing);
     }
 }

LightlessSync/Interop/Ipc/IpcCallerCustomize.cs

@@ -2,6 +2,7 @@
 using Dalamud.Plugin;
 using Dalamud.Plugin.Ipc;
 using Dalamud.Utility;
+using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.Services;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
@@ -9,8 +10,10 @@ using System.Text;
 
 namespace LightlessSync.Interop.Ipc;
 
-public sealed class IpcCallerCustomize : IIpcCaller
+public sealed class IpcCallerCustomize : IpcServiceBase
 {
+    private static readonly IpcServiceDescriptor CustomizeDescriptor = new("CustomizePlus", "Customize+", new Version(0, 0, 0, 0));
+
     private readonly ICallGateSubscriber<(int, int)> _customizePlusApiVersion;
     private readonly ICallGateSubscriber<ushort, (int, Guid?)> _customizePlusGetActiveProfile;
     private readonly ICallGateSubscriber<Guid, (int, string?)> _customizePlusGetProfileById;
@@ -23,7 +26,7 @@ public sealed class IpcCallerCustomize : IIpcCaller
     private readonly LightlessMediator _lightlessMediator;
 
     public IpcCallerCustomize(ILogger<IpcCallerCustomize> logger, IDalamudPluginInterface dalamudPluginInterface,
-        DalamudUtilService dalamudUtil, LightlessMediator lightlessMediator)
+        DalamudUtilService dalamudUtil, LightlessMediator lightlessMediator) : base(logger, lightlessMediator, dalamudPluginInterface, CustomizeDescriptor)
     {
         _customizePlusApiVersion = dalamudPluginInterface.GetIpcSubscriber<(int, int)>("CustomizePlus.General.GetApiVersion");
         _customizePlusGetActiveProfile = dalamudPluginInterface.GetIpcSubscriber<ushort, (int, Guid?)>("CustomizePlus.Profile.GetActiveProfileIdOnCharacter");
@@ -41,8 +44,6 @@ public sealed class IpcCallerCustomize : IIpcCaller
         CheckAPI();
     }
 
-    public bool APIAvailable { get; private set; } = false;
-
     public async Task RevertAsync(nint character)
     {
         if (!APIAvailable) return;
@@ -113,16 +114,25 @@ public sealed class IpcCallerCustomize : IIpcCaller
         return Convert.ToBase64String(Encoding.UTF8.GetBytes(scale));
     }
 
-    public void CheckAPI()
+    protected override IpcConnectionState EvaluateState()
     {
+        var state = base.EvaluateState();
+        if (state != IpcConnectionState.Available)
+        {
+            return state;
+        }
+
         try
         {
             var version = _customizePlusApiVersion.InvokeFunc();
-            APIAvailable = (version.Item1 == 6 && version.Item2 >= 0);
+            return version.Item1 == 6 && version.Item2 >= 0
+                ? IpcConnectionState.Available
+                : IpcConnectionState.VersionMismatch;
         }
-        catch
+        catch (Exception ex)
         {
-            APIAvailable = false;
+            Logger.LogDebug(ex, "Failed to query Customize+ API version");
+            return IpcConnectionState.Error;
         }
     }
 
@@ -132,8 +142,14 @@ public sealed class IpcCallerCustomize : IIpcCaller
         _lightlessMediator.Publish(new CustomizePlusMessage(obj?.Address ?? null));
     }
 
-    public void Dispose()
+    protected override void Dispose(bool disposing)
     {
+        base.Dispose(disposing);
+        if (!disposing)
+        {
+            return;
+        }
+
         _customizePlusOnScaleUpdate.Unsubscribe(OnCustomizePlusScaleChange);
     }
 }

LightlessSync/Interop/Ipc/IpcCallerGlamourer.cs

@@ -2,6 +2,7 @@
 using Dalamud.Plugin;
 using Glamourer.Api.Helpers;
 using Glamourer.Api.IpcSubscribers;
+using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.LightlessConfiguration.Models;
 using LightlessSync.PlayerData.Handlers;
 using LightlessSync.Services;
@@ -10,8 +11,9 @@ using Microsoft.Extensions.Logging;
 
 namespace LightlessSync.Interop.Ipc;
 
-public sealed class IpcCallerGlamourer : DisposableMediatorSubscriberBase, IIpcCaller
+public sealed class IpcCallerGlamourer : IpcServiceBase
 {
+    private static readonly IpcServiceDescriptor GlamourerDescriptor = new("Glamourer", "Glamourer", new Version(1, 3, 0, 10));
     private readonly ILogger<IpcCallerGlamourer> _logger;
     private readonly IDalamudPluginInterface _pi;
     private readonly DalamudUtilService _dalamudUtil;
@@ -31,7 +33,7 @@ public sealed class IpcCallerGlamourer : DisposableMediatorSubscriberBase, IIpcC
     private readonly uint LockCode = 0x6D617265;
 
     public IpcCallerGlamourer(ILogger<IpcCallerGlamourer> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil, LightlessMediator lightlessMediator,
-        RedrawManager redrawManager) : base(logger, lightlessMediator)
+        RedrawManager redrawManager) : base(logger, lightlessMediator, pi, GlamourerDescriptor)
     {
         _glamourerApiVersions = new ApiVersion(pi);
         _glamourerGetAllCustomization = new GetStateBase64(pi);
@@ -62,47 +64,6 @@ public sealed class IpcCallerGlamourer : DisposableMediatorSubscriberBase, IIpcC
         _glamourerStateChanged?.Dispose();
     }
 
-    public bool APIAvailable { get; private set; }
-
-    public void CheckAPI()
-    {
-        bool apiAvailable = false;
-        try
-        {
-            bool versionValid = (_pi.InstalledPlugins
-                .FirstOrDefault(p => string.Equals(p.InternalName, "Glamourer", StringComparison.OrdinalIgnoreCase))
-                ?.Version ?? new Version(0, 0, 0, 0)) >= new Version(1, 3, 0, 10);
-            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;
-                _lightlessMediator.Publish(new NotificationMessage("Glamourer inactive", "Your Glamourer installation is not active or out of date. Update Glamourer to continue to use Lightless. 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 fireAndForget = false)
     {
         if (!APIAvailable || string.IsNullOrEmpty(customization) || _dalamudUtil.IsZoning) return;
@@ -210,6 +171,49 @@ public sealed class IpcCallerGlamourer : DisposableMediatorSubscriberBase, IIpcC
         }
     }
 
+    protected override IpcConnectionState EvaluateState()
+    {
+        var state = base.EvaluateState();
+        if (state != IpcConnectionState.Available)
+        {
+            return state;
+        }
+
+        try
+        {
+            var version = _glamourerApiVersions.Invoke();
+            return version is { Major: 1, Minor: >= 1 }
+                ? IpcConnectionState.Available
+                : IpcConnectionState.VersionMismatch;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to query Glamourer API version");
+            return IpcConnectionState.Error;
+        }
+    }
+
+    protected override void OnConnectionStateChanged(IpcConnectionState previous, IpcConnectionState current)
+    {
+        base.OnConnectionStateChanged(previous, current);
+
+        if (current == IpcConnectionState.Available)
+        {
+            _shownGlamourerUnavailable = false;
+            return;
+        }
+
+        if (_shownGlamourerUnavailable || current == IpcConnectionState.Unknown)
+        {
+            return;
+        }
+
+        _shownGlamourerUnavailable = true;
+        _lightlessMediator.Publish(new NotificationMessage("Glamourer inactive",
+            "Your Glamourer installation is not active or out of date. Update Glamourer to continue to use Lightless. If you just updated Glamourer, ignore this message.",
+            NotificationType.Error));
+    }
+
     private void GlamourerChanged(nint address)
     {
         _lightlessMediator.Publish(new GlamourerChangedMessage(address));

LightlessSync/Interop/Ipc/IpcCallerHeels.cs

@@ -1,13 +1,16 @@
 using Dalamud.Plugin;
 using Dalamud.Plugin.Ipc;
+using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.Services;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
 
 namespace LightlessSync.Interop.Ipc;
 
-public sealed class IpcCallerHeels : IIpcCaller
+public sealed class IpcCallerHeels : IpcServiceBase
 {
+    private static readonly IpcServiceDescriptor HeelsDescriptor = new("SimpleHeels", "Simple Heels", new Version(0, 0, 0, 0));
+
     private readonly ILogger<IpcCallerHeels> _logger;
     private readonly LightlessMediator _lightlessMediator;
     private readonly DalamudUtilService _dalamudUtil;
@@ -18,6 +21,7 @@ public sealed class IpcCallerHeels : IIpcCaller
     private readonly ICallGateSubscriber<int, object?> _heelsUnregisterPlayer;
 
     public IpcCallerHeels(ILogger<IpcCallerHeels> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil, LightlessMediator lightlessMediator)
+        : base(logger, lightlessMediator, pi, HeelsDescriptor)
     {
         _logger = logger;
         _lightlessMediator = lightlessMediator;
@@ -32,8 +36,26 @@ public sealed class IpcCallerHeels : IIpcCaller
 
         CheckAPI();
     }
+    protected override IpcConnectionState EvaluateState()
+    {
+        var state = base.EvaluateState();
+        if (state != IpcConnectionState.Available)
+        {
+            return state;
+        }
 
-    public bool APIAvailable { get; private set; } = false;
+        try
+        {
+            return _heelsGetApiVersion.InvokeFunc() is { Item1: 2, Item2: >= 1 }
+                ? IpcConnectionState.Available
+                : IpcConnectionState.VersionMismatch;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to query SimpleHeels API version");
+            return IpcConnectionState.Error;
+        }
+    }
 
     private void HeelsOffsetChange(string offset)
     {
@@ -74,20 +96,14 @@ public sealed class IpcCallerHeels : IIpcCaller
         }).ConfigureAwait(false);
     }
 
-    public void CheckAPI()
+    protected override void Dispose(bool disposing)
     {
-        try
+        base.Dispose(disposing);
+        if (!disposing)
         {
-            APIAvailable = _heelsGetApiVersion.InvokeFunc() is { Item1: 2, Item2: >= 1 };
-        }
-        catch
-        {
-            APIAvailable = false;
-        }
+            return;
         }
 
-    public void Dispose()
-    {
         _heelsOffsetUpdate.Unsubscribe(HeelsOffsetChange);
     }
 }

LightlessSync/Interop/Ipc/IpcCallerHonorific.cs

@@ -1,6 +1,7 @@
 using Dalamud.Game.ClientState.Objects.SubKinds;
 using Dalamud.Plugin;
 using Dalamud.Plugin.Ipc;
+using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.Services;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
@@ -8,8 +9,10 @@ using System.Text;
 
 namespace LightlessSync.Interop.Ipc;
 
-public sealed class IpcCallerHonorific : IIpcCaller
+public sealed class IpcCallerHonorific : IpcServiceBase
 {
+    private static readonly IpcServiceDescriptor HonorificDescriptor = new("Honorific", "Honorific", new Version(0, 0, 0, 0));
+
     private readonly ICallGateSubscriber<(uint major, uint minor)> _honorificApiVersion;
     private readonly ICallGateSubscriber<int, object> _honorificClearCharacterTitle;
     private readonly ICallGateSubscriber<object> _honorificDisposing;
@@ -22,7 +25,7 @@ public sealed class IpcCallerHonorific : IIpcCaller
     private readonly DalamudUtilService _dalamudUtil;
 
     public IpcCallerHonorific(ILogger<IpcCallerHonorific> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil,
-        LightlessMediator lightlessMediator)
+        LightlessMediator lightlessMediator) : base(logger, lightlessMediator, pi, HonorificDescriptor)
     {
         _logger = logger;
         _lightlessMediator = lightlessMediator;
@@ -41,23 +44,14 @@ public sealed class IpcCallerHonorific : IIpcCaller
 
         CheckAPI();
     }
-
-    public bool APIAvailable { get; private set; } = false;
-
-    public void CheckAPI()
+    protected override void Dispose(bool disposing)
     {
-        try
+        base.Dispose(disposing);
+        if (!disposing)
         {
-            APIAvailable = _honorificApiVersion.InvokeFunc() is { Item1: 3, Item2: >= 1 };
-        }
-        catch
-        {
-            APIAvailable = false;
-        }
+            return;
         }
 
-    public void Dispose()
-    {
         _honorificLocalCharacterTitleChanged.Unsubscribe(OnHonorificLocalCharacterTitleChanged);
         _honorificDisposing.Unsubscribe(OnHonorificDisposing);
         _honorificReady.Unsubscribe(OnHonorificReady);
@@ -113,6 +107,27 @@ public sealed class IpcCallerHonorific : IIpcCaller
         }
     }
 
+    protected override IpcConnectionState EvaluateState()
+    {
+        var state = base.EvaluateState();
+        if (state != IpcConnectionState.Available)
+        {
+            return state;
+        }
+
+        try
+        {
+            return _honorificApiVersion.InvokeFunc() is { Item1: 3, Item2: >= 1 }
+                ? IpcConnectionState.Available
+                : IpcConnectionState.VersionMismatch;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to query Honorific API version");
+            return IpcConnectionState.Error;
+        }
+    }
+
     private void OnHonorificDisposing()
     {
         _lightlessMediator.Publish(new HonorificMessage(string.Empty));

LightlessSync/Interop/Ipc/IpcCallerLifestream.cs

@@ -0,0 +1,129 @@
+using Dalamud.Plugin;
+using Dalamud.Plugin.Ipc;
+using Lifestream.Enums;
+using LightlessSync.Interop.Ipc.Framework;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+
+namespace LightlessSync.Interop.Ipc;
+
+public sealed class IpcCallerLifestream : IpcServiceBase
+{
+    private static readonly IpcServiceDescriptor LifestreamDescriptor = new("Lifestream", "Lifestream", new Version(0, 0, 0, 0));
+
+    private readonly ICallGateSubscriber<string, object> _executeLifestreamCommand;
+    private readonly ICallGateSubscriber<AddressBookEntryTuple, bool> _isHere;
+    private readonly ICallGateSubscriber<AddressBookEntryTuple, object> _goToHousingAddress;
+    private readonly ICallGateSubscriber<bool> _isBusy;
+    private readonly ICallGateSubscriber<object> _abort;
+    private readonly ICallGateSubscriber<string, bool> _changeWorld;
+    private readonly ICallGateSubscriber<uint, bool> _changeWorldById;
+    private readonly ICallGateSubscriber<string, bool> _aetheryteTeleport;
+    private readonly ICallGateSubscriber<uint, bool> _aetheryteTeleportById;
+    private readonly ICallGateSubscriber<bool> _canChangeInstance;
+    private readonly ICallGateSubscriber<int> _getCurrentInstance;
+    private readonly ICallGateSubscriber<int> _getNumberOfInstances;
+    private readonly ICallGateSubscriber<int, object> _changeInstance;
+    private readonly ICallGateSubscriber<(ResidentialAetheryteKind, int, int)> _getCurrentPlotInfo;
+
+    public IpcCallerLifestream(IDalamudPluginInterface pi, LightlessMediator lightlessMediator, ILogger<IpcCallerLifestream> logger)
+        : base(logger, lightlessMediator, pi, LifestreamDescriptor)
+    {
+        _executeLifestreamCommand = pi.GetIpcSubscriber<string, object>("Lifestream.ExecuteCommand");
+        _isHere = pi.GetIpcSubscriber<AddressBookEntryTuple, bool>("Lifestream.IsHere");
+        _goToHousingAddress = pi.GetIpcSubscriber<AddressBookEntryTuple, object>("Lifestream.GoToHousingAddress");
+        _isBusy = pi.GetIpcSubscriber<bool>("Lifestream.IsBusy");
+        _abort = pi.GetIpcSubscriber<object>("Lifestream.Abort");
+        _changeWorld = pi.GetIpcSubscriber<string, bool>("Lifestream.ChangeWorld");
+        _changeWorldById = pi.GetIpcSubscriber<uint, bool>("Lifestream.ChangeWorldById");
+        _aetheryteTeleport = pi.GetIpcSubscriber<string, bool>("Lifestream.AetheryteTeleport");
+        _aetheryteTeleportById = pi.GetIpcSubscriber<uint, bool>("Lifestream.AetheryteTeleportById");
+        _canChangeInstance = pi.GetIpcSubscriber<bool>("Lifestream.CanChangeInstance");
+        _getCurrentInstance = pi.GetIpcSubscriber<int>("Lifestream.GetCurrentInstance");
+        _getNumberOfInstances = pi.GetIpcSubscriber<int>("Lifestream.GetNumberOfInstances");
+        _changeInstance = pi.GetIpcSubscriber<int, object>("Lifestream.ChangeInstance");
+        _getCurrentPlotInfo = pi.GetIpcSubscriber<(ResidentialAetheryteKind, int, int)>("Lifestream.GetCurrentPlotInfo");
+        CheckAPI();
+    }
+
+    public void ExecuteLifestreamCommand(string command)
+    {
+        if (!APIAvailable) return;
+        _executeLifestreamCommand.InvokeAction(command);
+    }
+
+    public bool IsHere(AddressBookEntryTuple entry)
+    {
+        if (!APIAvailable) return false;
+        return _isHere.InvokeFunc(entry);
+    }
+
+    public void GoToHousingAddress(AddressBookEntryTuple entry)
+    {
+        if (!APIAvailable) return;
+        _goToHousingAddress.InvokeAction(entry);
+    }
+
+    public bool IsBusy()
+    {
+        if (!APIAvailable) return false;
+        return _isBusy.InvokeFunc();
+    }
+
+    public void Abort()
+    {
+        if (!APIAvailable) return;
+        _abort.InvokeAction();
+    }
+
+    public bool ChangeWorld(string worldName)
+    {
+        if (!APIAvailable) return false;
+        return _changeWorld.InvokeFunc(worldName);
+    }
+
+    public bool AetheryteTeleport(string aetheryteName)
+    {
+        if (!APIAvailable) return false;
+        return _aetheryteTeleport.InvokeFunc(aetheryteName);
+    }
+
+    public bool ChangeWorldById(uint worldId)
+    {
+        if (!APIAvailable) return false;
+        return _changeWorldById.InvokeFunc(worldId);
+    }
+
+    public bool AetheryteTeleportById(uint aetheryteId)
+    {
+        if (!APIAvailable) return false;
+        return _aetheryteTeleportById.InvokeFunc(aetheryteId);
+    }
+
+    public bool CanChangeInstance()
+    {
+        if (!APIAvailable) return false;
+        return _canChangeInstance.InvokeFunc();
+    }
+    public int GetCurrentInstance()
+    {
+        if (!APIAvailable) return -1;
+        return _getCurrentInstance.InvokeFunc();
+    }
+    public int GetNumberOfInstances()
+    {
+        if (!APIAvailable) return -1;
+        return _getNumberOfInstances.InvokeFunc();
+    }
+    public void ChangeInstance(int instanceNumber)
+    {
+        if (!APIAvailable) return;
+        _changeInstance.InvokeAction(instanceNumber);
+    }
+    public (ResidentialAetheryteKind, int, int)? GetCurrentPlotInfo()
+    {
+        if (!APIAvailable) return (ResidentialAetheryteKind.None, -1, -1);
+        return _getCurrentPlotInfo.InvokeFunc();
+    }
+}

LightlessSync/Interop/Ipc/IpcCallerMoodles.cs

@@ -1,16 +1,18 @@
-using Dalamud.Game.ClientState.Objects.SubKinds;
-using Dalamud.Plugin;
+using Dalamud.Plugin;
 using Dalamud.Plugin.Ipc;
+using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.Services;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
 
 namespace LightlessSync.Interop.Ipc;
 
-public sealed class IpcCallerMoodles : IIpcCaller
+public sealed class IpcCallerMoodles : IpcServiceBase
 {
+    private static readonly IpcServiceDescriptor MoodlesDescriptor = new("Moodles", "Moodles", new Version(0, 0, 0, 0));
+
     private readonly ICallGateSubscriber<int> _moodlesApiVersion;
-    private readonly ICallGateSubscriber<IPlayerCharacter, object> _moodlesOnChange;
+    private readonly ICallGateSubscriber<nint, object> _moodlesOnChange;
     private readonly ICallGateSubscriber<nint, string> _moodlesGetStatus;
     private readonly ICallGateSubscriber<nint, string, object> _moodlesSetStatus;
     private readonly ICallGateSubscriber<nint, object> _moodlesRevertStatus;
@@ -19,44 +21,36 @@ public sealed class IpcCallerMoodles : IIpcCaller
     private readonly LightlessMediator _lightlessMediator;
 
     public IpcCallerMoodles(ILogger<IpcCallerMoodles> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil,
-        LightlessMediator lightlessMediator)
+        LightlessMediator lightlessMediator) : base(logger, lightlessMediator, pi, MoodlesDescriptor)
     {
         _logger = logger;
         _dalamudUtil = dalamudUtil;
         _lightlessMediator = lightlessMediator;
 
         _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 = pi.GetIpcSubscriber<nint, object>("Moodles.StatusManagerModified");
+        _moodlesGetStatus = pi.GetIpcSubscriber<nint, string>("Moodles.GetStatusManagerByPtrV2");
+        _moodlesSetStatus = pi.GetIpcSubscriber<nint, string, object>("Moodles.SetStatusManagerByPtrV2");
+        _moodlesRevertStatus = pi.GetIpcSubscriber<nint, object>("Moodles.ClearStatusManagerByPtrV2");
 
         _moodlesOnChange.Subscribe(OnMoodlesChange);
 
         CheckAPI();
     }
 
-    private void OnMoodlesChange(IPlayerCharacter character)
+    private void OnMoodlesChange(nint address)
     {
-        _lightlessMediator.Publish(new MoodlesMessage(character.Address));
+        _lightlessMediator.Publish(new MoodlesMessage(address));
     }
 
-    public bool APIAvailable { get; private set; } = false;
-
-    public void CheckAPI()
+    protected override void Dispose(bool disposing)
     {
-        try
+        base.Dispose(disposing);
+        if (!disposing)
         {
-            APIAvailable = _moodlesApiVersion.InvokeFunc() == 1;
-        }
-        catch
-        {
-            APIAvailable = false;
-        }
+            return;
         }
 
-    public void Dispose()
-    {
         _moodlesOnChange.Unsubscribe(OnMoodlesChange);
     }
 
@@ -101,4 +95,25 @@ public sealed class IpcCallerMoodles : IIpcCaller
             _logger.LogWarning(e, "Could not Set Moodles Status");
         }
     }
+
+    protected override IpcConnectionState EvaluateState()
+    {
+        var state = base.EvaluateState();
+        if (state != IpcConnectionState.Available)
+        {
+            return state;
+        }
+
+        try
+        {
+            return _moodlesApiVersion.InvokeFunc() >= 4
+                ? IpcConnectionState.Available
+                : IpcConnectionState.VersionMismatch;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to query Moodles API version");
+            return IpcConnectionState.Error;
+        }
+    }
 }

LightlessSync/Interop/Ipc/IpcCallerPenumbra.cs

@@ -1,4 +1,6 @@
-using Dalamud.Plugin;
+using Dalamud.Plugin;
+using LightlessSync.Interop.Ipc.Framework;
+using LightlessSync.Interop.Ipc.Penumbra;
 using LightlessSync.LightlessConfiguration.Models;
 using LightlessSync.PlayerData.Handlers;
 using LightlessSync.Services;
@@ -7,140 +9,199 @@ using Microsoft.Extensions.Logging;
 using Penumbra.Api.Enums;
 using Penumbra.Api.Helpers;
 using Penumbra.Api.IpcSubscribers;
-using System.Collections.Concurrent;
 
 namespace LightlessSync.Interop.Ipc;
 
-public sealed class IpcCallerPenumbra : DisposableMediatorSubscriberBase, IIpcCaller
+public sealed class IpcCallerPenumbra : IpcServiceBase
 {
-    private readonly IDalamudPluginInterface _pi;
-    private readonly DalamudUtilService _dalamudUtil;
-    private readonly LightlessMediator _lightlessMediator;
-    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;
-                _lightlessMediator.Publish(new PenumbraDirectoryChangedMessage(_penumbraModDirectory));
-            }
-        }
-    }
+    private static readonly IpcServiceDescriptor PenumbraDescriptor = new("Penumbra", "Penumbra", new Version(1, 2, 0, 22));
 
-    private readonly ConcurrentDictionary<IntPtr, bool> _penumbraRedrawRequests = new();
+    private readonly PenumbraCollections _collections;
+    private readonly PenumbraResource _resources;
+    private readonly PenumbraRedraw _redraw;
+    private readonly PenumbraTexture _textures;
 
-    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 readonly GetModDirectory _penumbraGetModDirectory;
+    private readonly EventSubscriber _penumbraInit;
+    private readonly EventSubscriber _penumbraDispose;
+    private readonly EventSubscriber<ModSettingChange, Guid, string, bool> _penumbraModSettingChanged;
 
-    public IpcCallerPenumbra(ILogger<IpcCallerPenumbra> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil,
-        LightlessMediator lightlessMediator, RedrawManager redrawManager) : base(logger, lightlessMediator)
-    {
-        _pi = pi;
-        _dalamudUtil = dalamudUtil;
-        _lightlessMediator = lightlessMediator;
-        _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)
-                _lightlessMediator.Publish(new PenumbraModSettingChangedMessage());
-        });
-        _penumbraConvertTextureFile = new ConvertTextureFile(pi);
-        _penumbraResourcePaths = new GetGameObjectResourcePaths(pi);
+    private bool _shownPenumbraUnavailable;
+    private string? _modDirectory;
 
-        _penumbraGameObjectResourcePathResolved = GameObjectResourcePathResolved.Subscriber(pi, ResourceLoaded);
+    public IpcCallerPenumbra(
+        ILogger<IpcCallerPenumbra> logger,
+        IDalamudPluginInterface pluginInterface,
+        DalamudUtilService dalamudUtil,
+        LightlessMediator mediator,
+        RedrawManager redrawManager) : base(logger, mediator, pluginInterface, PenumbraDescriptor)
+    {
+        _penumbraEnabled = new GetEnabledState(pluginInterface);
+        _penumbraGetModDirectory = new GetModDirectory(pluginInterface);
+        _penumbraInit = Initialized.Subscriber(pluginInterface, HandlePenumbraInitialized);
+        _penumbraDispose = Disposed.Subscriber(pluginInterface, HandlePenumbraDisposed);
+        _penumbraModSettingChanged = ModSettingChanged.Subscriber(pluginInterface, HandlePenumbraModSettingChanged);
+
+        _collections = RegisterInterop(new PenumbraCollections(logger, pluginInterface, dalamudUtil, mediator));
+        _resources = RegisterInterop(new PenumbraResource(logger, pluginInterface, dalamudUtil, mediator));
+        _redraw = RegisterInterop(new PenumbraRedraw(logger, pluginInterface, dalamudUtil, mediator, redrawManager));
+        _textures = RegisterInterop(new PenumbraTexture(logger, pluginInterface, dalamudUtil, mediator, _redraw));
+
+        SubscribeMediatorEvents();
 
         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 string? ModDirectory
+    {
+        get => _modDirectory;
+        private set
+        {
+            if (string.Equals(_modDirectory, value, StringComparison.Ordinal))
+            {
+                return;
+            }
 
-    public void CheckAPI()
-    {
-        bool penumbraAvailable = false;
-        try
-        {
-            var penumbraVersion = (_pi.InstalledPlugins
-                .FirstOrDefault(p => string.Equals(p.InternalName, "Penumbra", StringComparison.OrdinalIgnoreCase))
-                ?.Version ?? new Version(0, 0, 0, 0));
-            penumbraAvailable = penumbraVersion >= new Version(1, 2, 0, 22);
-            try
-            {
-                penumbraAvailable &= _penumbraEnabled.Invoke();
-            }
-            catch
-            {
-                penumbraAvailable = false;
-            }
-            _shownPenumbraUnavailable = _shownPenumbraUnavailable && !penumbraAvailable;
-            APIAvailable = penumbraAvailable;
-        }
-        catch
-        {
-            APIAvailable = penumbraAvailable;
-        }
-        finally
-        {
-            if (!penumbraAvailable && !_shownPenumbraUnavailable)
-            {
-                _shownPenumbraUnavailable = true;
-                _lightlessMediator.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 Lightless. If you just updated Penumbra, ignore this message.",
-                    NotificationType.Error));
-            }
+            _modDirectory = value;
+            Mediator.Publish(new PenumbraDirectoryChangedMessage(_modDirectory));
         }
     }
 
+    public Task AssignTemporaryCollectionAsync(ILogger logger, Guid collectionId, int objectIndex)
+        => _collections.AssignTemporaryCollectionAsync(logger, collectionId, objectIndex);
+
+    public Task<Guid> CreateTemporaryCollectionAsync(ILogger logger, string uid)
+        => _collections.CreateTemporaryCollectionAsync(logger, uid);
+
+    public Task RemoveTemporaryCollectionAsync(ILogger logger, Guid applicationId, Guid collectionId)
+        => _collections.RemoveTemporaryCollectionAsync(logger, applicationId, collectionId);
+
+    public Task SetTemporaryModsAsync(ILogger logger, Guid applicationId, Guid collectionId, Dictionary<string, string> modPaths)
+        => _collections.SetTemporaryModsAsync(logger, applicationId, collectionId, modPaths);
+
+    public Task SetManipulationDataAsync(ILogger logger, Guid applicationId, Guid collectionId, string manipulationData)
+        => _collections.SetManipulationDataAsync(logger, applicationId, collectionId, manipulationData);
+
+    public Task<Dictionary<string, HashSet<string>>?> GetCharacterData(ILogger logger, GameObjectHandler handler)
+        => _resources.GetCharacterDataAsync(logger, handler);
+
+    public string GetMetaManipulations()
+        => _resources.GetMetaManipulations();
+
+    public Task<(string[] forward, string[][] reverse)> ResolvePathsAsync(string[] forward, string[] reverse)
+        => _resources.ResolvePathsAsync(forward, reverse);
+
+    public string ResolveGameObjectPath(string gamePath, int objectIndex)
+        => _resources.ResolveGameObjectPath(gamePath, objectIndex);
+
+    public string[] ReverseResolveGameObjectPath(string moddedPath, int objectIndex)
+        => _resources.ReverseResolveGameObjectPath(moddedPath, objectIndex);
+
+    public Task RedrawAsync(ILogger logger, GameObjectHandler handler, Guid applicationId, CancellationToken token)
+        => _redraw.RedrawAsync(logger, handler, applicationId, token);
+
+    public void RequestImmediateRedraw(int objectIndex, RedrawType redrawType)
+        => _redraw.RequestImmediateRedraw(objectIndex, redrawType);
+
+    public Task ConvertTextureFiles(ILogger logger, IReadOnlyList<TextureConversionJob> jobs, IProgress<TextureConversionProgress>? progress, CancellationToken token, bool requestRedraw = true)
+        => _textures.ConvertTextureFilesAsync(logger, jobs, progress, token, requestRedraw);
+
+    public Task ConvertTextureFileDirectAsync(TextureConversionJob job, CancellationToken token)
+        => _textures.ConvertTextureFileDirectAsync(job, token);
+
     public void CheckModDirectory()
     {
         if (!APIAvailable)
         {
             ModDirectory = string.Empty;
+            return;
         }
-        else
+
+        try
         {
-            ModDirectory = _penumbraResolveModDir!.Invoke().ToLowerInvariant();
+            ModDirectory = _penumbraGetModDirectory.Invoke().ToLowerInvariant();
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Failed to resolve Penumbra mod directory");
+        }
+    }
+
+    protected override bool IsPluginEnabled(IExposedPlugin plugin)
+    {
+        try
+        {
+            return _penumbraEnabled.Invoke();
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    protected override void OnConnectionStateChanged(IpcConnectionState previous, IpcConnectionState current)
+    {
+        base.OnConnectionStateChanged(previous, current);
+
+        if (current == IpcConnectionState.Available)
+        {
+            _shownPenumbraUnavailable = false;
+            if (string.IsNullOrEmpty(ModDirectory))
+            {
+                CheckModDirectory();
+            }
+            return;
+        }
+
+        ModDirectory = string.Empty;
+        _redraw.CancelPendingRedraws();
+
+        if (_shownPenumbraUnavailable || current == IpcConnectionState.Unknown)
+        {
+            return;
+        }
+
+        _shownPenumbraUnavailable = true;
+        Mediator.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 Lightless. If you just updated Penumbra, ignore this message.",
+            NotificationType.Error));
+    }
+
+    private void SubscribeMediatorEvents()
+    {
+        Mediator.Subscribe<PenumbraRedrawCharacterMessage>(this, msg =>
+        {
+            _redraw.RequestImmediateRedraw(msg.Character.ObjectIndex, RedrawType.AfterGPose);
+        });
+
+        Mediator.Subscribe<DalamudLoginMessage>(this, _ => _shownPenumbraUnavailable = false);
+    }
+
+    private void HandlePenumbraInitialized()
+    {
+        Mediator.Publish(new PenumbraInitializedMessage());
+        CheckModDirectory();
+        _redraw.RequestImmediateRedraw(0, RedrawType.Redraw);
+        CheckAPI();
+    }
+
+    private void HandlePenumbraDisposed()
+    {
+        _redraw.CancelPendingRedraws();
+        ModDirectory = string.Empty;
+        Mediator.Publish(new PenumbraDisposedMessage());
+        CheckAPI();
+    }
+
+    private void HandlePenumbraModSettingChanged(ModSettingChange change, Guid _, string __, bool ___)
+    {
+        if (change == ModSettingChange.EnableState)
+        {
+            Mediator.Publish(new PenumbraModSettingChangedMessage());
+            CheckAPI();
         }
     }
 
@@ -148,196 +209,13 @@ public sealed class IpcCallerPenumbra : DisposableMediatorSubscriberBase, IIpcCa
     {
         base.Dispose(disposing);
 
-        _redrawManager.Cancel();
+        if (!disposing)
+        {
+            return;
+        }
 
         _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;
-
-        _lightlessMediator.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);
-                    }
-                }
-            }
-        }
-        _lightlessMediator.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 = "Lightless_" + 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 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("LightlessChara_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("LightlessChara_Files", collId, 0);
-            logger.LogTrace("[{applicationId}] Removing temp files mod for {collId}, Success: {ret}", applicationId, collId, retRemove);
-            var retAdd = _penumbraAddTemporaryMod.Invoke("LightlessChara_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
-        {
-            _lightlessMediator.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)
-        {
-            _lightlessMediator.Publish(new PenumbraResourceLoadMessage(ptr, arg1, arg2));
-        }
-    }
-
-    private void PenumbraDispose()
-    {
-        _redrawManager.Cancel();
-        _lightlessMediator.Publish(new PenumbraDisposedMessage());
-    }
-
-    private void PenumbraInit()
-    {
-        APIAvailable = true;
-        ModDirectory = _penumbraResolveModDir.Invoke();
-        _lightlessMediator.Publish(new PenumbraInitializedMessage());
-        _penumbraRedraw!.Invoke(0, setting: RedrawType.Redraw);
     }
 }

LightlessSync/Interop/Ipc/IpcCallerPetNames.cs

@@ -1,14 +1,17 @@
 using Dalamud.Game.ClientState.Objects.SubKinds;
 using Dalamud.Plugin;
 using Dalamud.Plugin.Ipc;
+using LightlessSync.Interop.Ipc.Framework;
 using LightlessSync.Services;
 using LightlessSync.Services.Mediator;
 using Microsoft.Extensions.Logging;
 
 namespace LightlessSync.Interop.Ipc;
 
-public sealed class IpcCallerPetNames : IIpcCaller
+public sealed class IpcCallerPetNames : IpcServiceBase
 {
+    private static readonly IpcServiceDescriptor PetRenamerDescriptor = new("PetRenamer", "Pet Renamer", new Version(0, 0, 0, 0));
+
     private readonly ILogger<IpcCallerPetNames> _logger;
     private readonly DalamudUtilService _dalamudUtil;
     private readonly LightlessMediator _lightlessMediator;
@@ -24,18 +27,18 @@ public sealed class IpcCallerPetNames : IIpcCaller
     private readonly ICallGateSubscriber<ushort, object> _clearPlayerData;
 
     public IpcCallerPetNames(ILogger<IpcCallerPetNames> logger, IDalamudPluginInterface pi, DalamudUtilService dalamudUtil,
-        LightlessMediator lightlessMediator)
+        LightlessMediator lightlessMediator) : base(logger, lightlessMediator, pi, PetRenamerDescriptor)
     {
         _logger = logger;
         _dalamudUtil = dalamudUtil;
         _lightlessMediator = lightlessMediator;
 
-        _petnamesReady = pi.GetIpcSubscriber<object>("PetRenamer.Ready");
-        _petnamesDisposing = pi.GetIpcSubscriber<object>("PetRenamer.Disposing");
+        _petnamesReady = pi.GetIpcSubscriber<object>("PetRenamer.OnReady");
+        _petnamesDisposing = pi.GetIpcSubscriber<object>("PetRenamer.OnDisposing");
         _apiVersion = pi.GetIpcSubscriber<(uint, uint)>("PetRenamer.ApiVersion");
-        _enabled = pi.GetIpcSubscriber<bool>("PetRenamer.Enabled");
+        _enabled = pi.GetIpcSubscriber<bool>("PetRenamer.IsEnabled");
 
-        _playerDataChanged = pi.GetIpcSubscriber<string, object>("PetRenamer.PlayerDataChanged");
+        _playerDataChanged = pi.GetIpcSubscriber<string, object>("PetRenamer.OnPlayerDataChanged");
         _getPlayerData = pi.GetIpcSubscriber<string>("PetRenamer.GetPlayerData");
         _setPlayerData = pi.GetIpcSubscriber<string, object>("PetRenamer.SetPlayerData");
         _clearPlayerData = pi.GetIpcSubscriber<ushort, object>("PetRenamer.ClearPlayerData");
@@ -46,25 +49,6 @@ public sealed class IpcCallerPetNames : IIpcCaller
 
         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();
@@ -76,6 +60,34 @@ public sealed class IpcCallerPetNames : IIpcCaller
         _lightlessMediator.Publish(new PetNamesMessage(string.Empty));
     }
 
+    protected override IpcConnectionState EvaluateState()
+    {
+        var state = base.EvaluateState();
+        if (state != IpcConnectionState.Available)
+        {
+            return state;
+        }
+
+        try
+        {
+            var enabled = _enabled?.InvokeFunc() ?? false;
+            if (!enabled)
+            {
+                return IpcConnectionState.PluginDisabled;
+            }
+
+            var version = _apiVersion?.InvokeFunc() ?? (0u, 0u);
+            return version.Item1 == 4 && version.Item2 >= 0
+                ? IpcConnectionState.Available
+                : IpcConnectionState.VersionMismatch;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogDebug(ex, "Failed to query Pet Renamer API version");
+            return IpcConnectionState.Error;
+        }
+    }
+
     public string GetLocalNames()
     {
         if (!APIAvailable) return string.Empty;
@@ -149,8 +161,14 @@ public sealed class IpcCallerPetNames : IIpcCaller
         _lightlessMediator.Publish(new PetNamesMessage(data));
     }
 
-    public void Dispose()
+    protected override void Dispose(bool disposing)
     {
+        base.Dispose(disposing);
+        if (!disposing)
+        {
+            return;
+        }
+
         _petnamesReady.Unsubscribe(OnPetNicknamesReady);
         _petnamesDisposing.Unsubscribe(OnPetNicknamesDispose);
         _playerDataChanged.Unsubscribe(OnLocalPetNicknamesDataChange);

LightlessSync/Interop/Ipc/IpcManager.cs

@@ -5,9 +5,12 @@ namespace LightlessSync.Interop.Ipc;
 
 public sealed partial class IpcManager : DisposableMediatorSubscriberBase
 {
+    private bool _wasInitialized;
+
     public IpcManager(ILogger<IpcManager> logger, LightlessMediator mediator,
         IpcCallerPenumbra penumbraIpc, IpcCallerGlamourer glamourerIpc, IpcCallerCustomize customizeIpc, IpcCallerHeels heelsIpc,
-        IpcCallerHonorific honorificIpc, IpcCallerMoodles moodlesIpc, IpcCallerPetNames ipcCallerPetNames, IpcCallerBrio ipcCallerBrio) : base(logger, mediator)
+        IpcCallerHonorific honorificIpc, IpcCallerMoodles moodlesIpc, IpcCallerPetNames ipcCallerPetNames, IpcCallerBrio ipcCallerBrio,
+        IpcCallerLifestream ipcCallerLifestream) : base(logger, mediator)
     {
         CustomizePlus = customizeIpc;
         Heels = heelsIpc;
@@ -17,8 +20,10 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
         Moodles = moodlesIpc;
         PetNames = ipcCallerPetNames;
         Brio = ipcCallerBrio;
+        Lifestream = ipcCallerLifestream;
 
-        if (Initialized)
+        _wasInitialized = Initialized;
+        if (_wasInitialized)
         {
             Mediator.Publish(new PenumbraInitializedMessage());
         }
@@ -44,8 +49,8 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
     public IpcCallerPenumbra Penumbra { get; }
     public IpcCallerMoodles Moodles { get; }
     public IpcCallerPetNames PetNames { get; }
-
     public IpcCallerBrio Brio { get; }
+    public IpcCallerLifestream Lifestream { get; }
 
     private void PeriodicApiStateCheck()
     {
@@ -58,5 +63,14 @@ public sealed partial class IpcManager : DisposableMediatorSubscriberBase
         Moodles.CheckAPI();
         PetNames.CheckAPI();
         Brio.CheckAPI();
+
+        var initialized = Initialized;
+        if (initialized && !_wasInitialized)
+        {
+            Mediator.Publish(new PenumbraInitializedMessage());
+        }
+
+        _wasInitialized = initialized;
+        Lifestream.CheckAPI();
     }
 }

LightlessSync/Interop/Ipc/IpcProvider.cs

@@ -1,4 +1,5 @@
-using Dalamud.Game.ClientState.Objects.Types;
+using System;
+using Dalamud.Game.ClientState.Objects.Types;
 using Dalamud.Plugin;
 using Dalamud.Plugin.Ipc;
 using LightlessSync.PlayerData.Handlers;
@@ -14,9 +15,7 @@ public class IpcProvider : IHostedService, IMediatorSubscriber
     private readonly ILogger<IpcProvider> _logger;
     private readonly IDalamudPluginInterface _pi;
     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<IpcRegister> _ipcRegisters = [];
     private readonly List<GameObjectHandler> _activeGameObjectHandlers = [];
 
     public LightlessMediator Mediator { get; init; }
@@ -44,12 +43,9 @@ public class IpcProvider : IHostedService, IMediatorSubscriber
     public Task StartAsync(CancellationToken cancellationToken)
     {
         _logger.LogInformation("Starting IpcProviderService");
-        _loadFileProvider = _pi.GetIpcProvider<string, IGameObject, bool>("LightlessSync.LoadMcdf");
-        _loadFileProvider.RegisterFunc(LoadMcdf);
-        _loadFileAsyncProvider = _pi.GetIpcProvider<string, IGameObject, Task<bool>>("LightlessSync.LoadMcdfAsync");
-        _loadFileAsyncProvider.RegisterFunc(LoadMcdfAsync);
-        _handledGameAddresses = _pi.GetIpcProvider<List<nint>>("LightlessSync.GetHandledAddresses");
-        _handledGameAddresses.RegisterFunc(GetHandledAddresses);
+        _ipcRegisters.Add(RegisterFunc<string, IGameObject, bool>("LightlessSync.LoadMcdf", LoadMcdf));
+        _ipcRegisters.Add(RegisterFunc<string, IGameObject, Task<bool>>("LightlessSync.LoadMcdfAsync", LoadMcdfAsync));
+        _ipcRegisters.Add(RegisterFunc("LightlessSync.GetHandledAddresses", GetHandledAddresses));
         _logger.LogInformation("Started IpcProviderService");
         return Task.CompletedTask;
     }
@@ -57,9 +53,11 @@ public class IpcProvider : IHostedService, IMediatorSubscriber
     public Task StopAsync(CancellationToken cancellationToken)
     {
         _logger.LogDebug("Stopping IpcProvider Service");
-        _loadFileProvider?.UnregisterFunc();
-        _loadFileAsyncProvider?.UnregisterFunc();
-        _handledGameAddresses?.UnregisterFunc();
+        foreach (var register in _ipcRegisters)
+        {
+            register.Dispose();
+        }
+        _ipcRegisters.Clear();
         Mediator.UnsubscribeAll(this);
         return Task.CompletedTask;
     }
@@ -89,4 +87,40 @@ public class IpcProvider : IHostedService, IMediatorSubscriber
     {
         return _activeGameObjectHandlers.Where(g => g.Address != nint.Zero).Select(g => g.Address).Distinct().ToList();
     }
+
+    private IpcRegister RegisterFunc(string label, Func<List<nint>> handler)
+    {
+        var provider = _pi.GetIpcProvider<List<nint>>(label);
+        provider.RegisterFunc(handler);
+        return new IpcRegister(provider.UnregisterFunc);
+    }
+
+    private IpcRegister RegisterFunc<T1, T2, TRet>(string label, Func<T1, T2, TRet> handler)
+    {
+        var provider = _pi.GetIpcProvider<T1, T2, TRet>(label);
+        provider.RegisterFunc(handler);
+        return new IpcRegister(provider.UnregisterFunc);
+    }
+
+    private sealed class IpcRegister : IDisposable
+    {
+        private readonly Action _unregister;
+        private bool _disposed;
+
+        public IpcRegister(Action unregister)
+        {
+            _unregister = unregister;
+        }
+
+        public void Dispose()
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            _unregister();
+            _disposed = true;
+        }
+    }
 }

LightlessSync/Interop/Ipc/Penumbra/PenumbraBase.cs

@@ -0,0 +1,27 @@
+using Dalamud.Plugin;
+using LightlessSync.Interop.Ipc.Framework;
+using LightlessSync.Services;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+
+namespace LightlessSync.Interop.Ipc.Penumbra;
+
+public abstract class PenumbraBase : IpcInteropBase
+{
+    protected PenumbraBase(
+        ILogger logger,
+        IDalamudPluginInterface pluginInterface,
+        DalamudUtilService dalamudUtil,
+        LightlessMediator mediator) : base(logger)
+    {
+        PluginInterface = pluginInterface;
+        DalamudUtil = dalamudUtil;
+        Mediator = mediator;
+    }
+
+    protected IDalamudPluginInterface PluginInterface { get; }
+
+    protected DalamudUtilService DalamudUtil { get; }
+
+    protected LightlessMediator Mediator { get; }
+}

LightlessSync/Interop/Ipc/Penumbra/PenumbraCollections.cs

@@ -0,0 +1,122 @@
+using Dalamud.Plugin;
+using LightlessSync.Interop.Ipc.Framework;
+using LightlessSync.Services;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using Penumbra.Api.IpcSubscribers;
+
+namespace LightlessSync.Interop.Ipc.Penumbra;
+
+public sealed class PenumbraCollections : PenumbraBase
+{
+    private readonly CreateTemporaryCollection _createNamedTemporaryCollection;
+    private readonly AssignTemporaryCollection _assignTemporaryCollection;
+    private readonly DeleteTemporaryCollection _removeTemporaryCollection;
+    private readonly AddTemporaryMod _addTemporaryMod;
+    private readonly RemoveTemporaryMod _removeTemporaryMod;
+
+    public PenumbraCollections(
+        ILogger logger,
+        IDalamudPluginInterface pluginInterface,
+        DalamudUtilService dalamudUtil,
+        LightlessMediator mediator) : base(logger, pluginInterface, dalamudUtil, mediator)
+    {
+        _createNamedTemporaryCollection = new CreateTemporaryCollection(pluginInterface);
+        _assignTemporaryCollection = new AssignTemporaryCollection(pluginInterface);
+        _removeTemporaryCollection = new DeleteTemporaryCollection(pluginInterface);
+        _addTemporaryMod = new AddTemporaryMod(pluginInterface);
+        _removeTemporaryMod = new RemoveTemporaryMod(pluginInterface);
+    }
+
+    public override string Name => "Penumbra.Collections";
+
+    public async Task AssignTemporaryCollectionAsync(ILogger logger, Guid collectionId, int objectIndex)
+    {
+        if (!IsAvailable || collectionId == Guid.Empty)
+        {
+            return;
+        }
+
+        await DalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var result = _assignTemporaryCollection.Invoke(collectionId, objectIndex, forceAssignment: true);
+            logger.LogTrace("Assigning Temp Collection {CollectionId} to index {ObjectIndex}, Success: {Result}", collectionId, objectIndex, result);
+            return result;
+        }).ConfigureAwait(false);
+    }
+
+    public async Task<Guid> CreateTemporaryCollectionAsync(ILogger logger, string uid)
+    {
+        if (!IsAvailable)
+        {
+            return Guid.Empty;
+        }
+
+        var (collectionId, collectionName) = await DalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var name = $"Lightless_{uid}";
+            var createResult = _createNamedTemporaryCollection.Invoke(name, name, out var tempCollectionId);
+            logger.LogTrace("Creating Temp Collection {CollectionName}, GUID: {CollectionId}, Result: {Result}", name, tempCollectionId, createResult);
+            return (tempCollectionId, name);
+        }).ConfigureAwait(false);
+
+        return collectionId;
+    }
+
+    public async Task RemoveTemporaryCollectionAsync(ILogger logger, Guid applicationId, Guid collectionId)
+    {
+        if (!IsAvailable || collectionId == Guid.Empty)
+        {
+            return;
+        }
+
+        await DalamudUtil.RunOnFrameworkThread(() =>
+        {
+            logger.LogTrace("[{ApplicationId}] Removing temp collection for {CollectionId}", applicationId, collectionId);
+            var result = _removeTemporaryCollection.Invoke(collectionId);
+            logger.LogTrace("[{ApplicationId}] RemoveTemporaryCollection: {Result}", applicationId, result);
+        }).ConfigureAwait(false);
+
+    }
+
+    public async Task SetTemporaryModsAsync(ILogger logger, Guid applicationId, Guid collectionId, Dictionary<string, string> modPaths)
+    {
+        if (!IsAvailable || collectionId == Guid.Empty)
+        {
+            return;
+        }
+
+        await DalamudUtil.RunOnFrameworkThread(() =>
+        {
+            foreach (var mod in modPaths)
+            {
+                logger.LogTrace("[{ApplicationId}] Change: {From} => {To}", applicationId, mod.Key, mod.Value);
+            }
+
+            var removeResult = _removeTemporaryMod.Invoke("LightlessChara_Files", collectionId, 0);
+            logger.LogTrace("[{ApplicationId}] Removing temp files mod for {CollectionId}, Success: {Result}", applicationId, collectionId, removeResult);
+
+            var addResult = _addTemporaryMod.Invoke("LightlessChara_Files", collectionId, modPaths, string.Empty, 0);
+            logger.LogTrace("[{ApplicationId}] Setting temp files mod for {CollectionId}, Success: {Result}", applicationId, collectionId, addResult);
+        }).ConfigureAwait(false);
+    }
+
+    public async Task SetManipulationDataAsync(ILogger logger, Guid applicationId, Guid collectionId, string manipulationData)
+    {
+        if (!IsAvailable || collectionId == Guid.Empty)
+        {
+            return;
+        }
+
+        await DalamudUtil.RunOnFrameworkThread(() =>
+        {
+            logger.LogTrace("[{ApplicationId}] Manip: {Data}", applicationId, manipulationData);
+            var result = _addTemporaryMod.Invoke("LightlessChara_Meta", collectionId, [], manipulationData, 0);
+            logger.LogTrace("[{ApplicationId}] Setting temp meta mod for {CollectionId}, Success: {Result}", applicationId, collectionId, result);
+        }).ConfigureAwait(false);
+    }
+
+    protected override void HandleStateChange(IpcConnectionState previous, IpcConnectionState current)
+    {
+    }
+}

LightlessSync/Interop/Ipc/Penumbra/PenumbraRedraw.cs

@@ -0,0 +1,89 @@
+using Dalamud.Plugin;
+using LightlessSync.Interop.Ipc.Framework;
+using LightlessSync.PlayerData.Handlers;
+using LightlessSync.Services;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using Penumbra.Api.Enums;
+using Penumbra.Api.Helpers;
+using Penumbra.Api.IpcSubscribers;
+
+namespace LightlessSync.Interop.Ipc.Penumbra;
+
+public sealed class PenumbraRedraw : PenumbraBase
+{
+    private readonly RedrawManager _redrawManager;
+    private readonly RedrawObject _penumbraRedraw;
+    private readonly EventSubscriber<nint, int> _penumbraObjectIsRedrawn;
+
+    public PenumbraRedraw(
+        ILogger logger,
+        IDalamudPluginInterface pluginInterface,
+        DalamudUtilService dalamudUtil,
+        LightlessMediator mediator,
+        RedrawManager redrawManager) : base(logger, pluginInterface, dalamudUtil, mediator)
+    {
+        _redrawManager = redrawManager;
+
+        _penumbraRedraw = new RedrawObject(pluginInterface);
+        _penumbraObjectIsRedrawn = GameObjectRedrawn.Subscriber(pluginInterface, HandlePenumbraRedrawEvent);
+    }
+
+    public override string Name => "Penumbra.Redraw";
+
+    public void CancelPendingRedraws()
+        => _redrawManager.Cancel();
+
+    public void RequestImmediateRedraw(int objectIndex, RedrawType redrawType)
+    {
+        if (!IsAvailable)
+        {
+            return;
+        }
+
+        _penumbraRedraw.Invoke(objectIndex, redrawType);
+    }
+
+    public async Task RedrawAsync(ILogger logger, GameObjectHandler handler, Guid applicationId, CancellationToken token)
+    {
+        if (!IsAvailable || DalamudUtil.IsZoning)
+        {
+            return;
+        }
+
+        var redrawSemaphore = _redrawManager.RedrawSemaphore;
+        var semaphoreAcquired = false;
+
+        try
+        {
+            await redrawSemaphore.WaitAsync(token).ConfigureAwait(false);
+            semaphoreAcquired = true;
+
+            await _redrawManager.PenumbraRedrawInternalAsync(logger, handler, applicationId, chara =>
+            {
+                logger.LogDebug("[{ApplicationId}] Calling on IPC: PenumbraRedraw", applicationId);
+                _penumbraRedraw.Invoke(chara.ObjectIndex, RedrawType.Redraw);
+            }, token).ConfigureAwait(false);
+        }
+        finally
+        {
+            if (semaphoreAcquired)
+            {
+                redrawSemaphore.Release();
+            }
+        }
+    }
+
+    private void HandlePenumbraRedrawEvent(IntPtr objectAddress, int objectTableIndex)
+        => Mediator.Publish(new PenumbraRedrawMessage(objectAddress, objectTableIndex, false));
+
+    protected override void HandleStateChange(IpcConnectionState previous, IpcConnectionState current)
+    {
+    }
+
+    public override void Dispose()
+    {
+        base.Dispose();
+        _penumbraObjectIsRedrawn.Dispose();
+    }
+}

LightlessSync/Interop/Ipc/Penumbra/PenumbraResource.cs

@@ -0,0 +1,111 @@
+using Dalamud.Plugin;
+using LightlessSync.Interop.Ipc.Framework;
+using LightlessSync.PlayerData.Handlers;
+using LightlessSync.Services;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using System.Diagnostics;
+using System.Globalization;
+using Penumbra.Api.Helpers;
+using Penumbra.Api.IpcSubscribers;
+
+namespace LightlessSync.Interop.Ipc.Penumbra;
+
+public sealed class PenumbraResource : PenumbraBase
+{
+    private readonly GetGameObjectResourcePaths _gameObjectResourcePaths;
+    private readonly ResolveGameObjectPath _resolveGameObjectPath;
+    private readonly ReverseResolveGameObjectPath _reverseResolveGameObjectPath;
+    private readonly ResolvePlayerPathsAsync _resolvePlayerPaths;
+    private readonly GetPlayerMetaManipulations _getPlayerMetaManipulations;
+    private readonly EventSubscriber<nint, string, string> _gameObjectResourcePathResolved;
+
+    public PenumbraResource(
+        ILogger logger,
+        IDalamudPluginInterface pluginInterface,
+        DalamudUtilService dalamudUtil,
+        LightlessMediator mediator) : base(logger, pluginInterface, dalamudUtil, mediator)
+    {
+        _gameObjectResourcePaths = new GetGameObjectResourcePaths(pluginInterface);
+        _resolveGameObjectPath = new ResolveGameObjectPath(pluginInterface);
+        _reverseResolveGameObjectPath = new ReverseResolveGameObjectPath(pluginInterface);
+        _resolvePlayerPaths = new ResolvePlayerPathsAsync(pluginInterface);
+        _getPlayerMetaManipulations = new GetPlayerMetaManipulations(pluginInterface);
+        _gameObjectResourcePathResolved = GameObjectResourcePathResolved.Subscriber(pluginInterface, HandleResourceLoaded);
+    }
+
+    public override string Name => "Penumbra.Resources";
+
+    public async Task<Dictionary<string, HashSet<string>>?> GetCharacterDataAsync(ILogger logger, GameObjectHandler handler)
+    {
+        if (!IsAvailable)
+        {
+            return null;
+        }
+
+        var requestId = Guid.NewGuid();
+        var totalTimer = Stopwatch.StartNew();
+        logger.LogTrace("[{requestId}] Requesting Penumbra.GetGameObjectResourcePaths for {handler}", requestId, handler);
+
+        var result = await DalamudUtil.RunOnFrameworkThread(() =>
+        {
+            var idx = handler.GetGameObject()?.ObjectIndex;
+            if (idx == null)
+            {
+                logger.LogTrace("[{requestId}] GetGameObjectResourcePaths aborted (missing object index) for {handler}", requestId, handler);
+                return null;
+            }
+
+            logger.LogTrace("[{requestId}] Invoking Penumbra.GetGameObjectResourcePaths for index {index}", requestId, idx.Value);
+            var invokeTimer = Stopwatch.StartNew();
+            var data = _gameObjectResourcePaths.Invoke(idx.Value)[0];
+            invokeTimer.Stop();
+            logger.LogTrace("[{requestId}] Penumbra.GetGameObjectResourcePaths returned {count} entries in {elapsedMs}ms",
+                requestId, data?.Count ?? 0, invokeTimer.ElapsedMilliseconds);
+            return data;
+        }).ConfigureAwait(false);
+
+        totalTimer.Stop();
+        logger.LogTrace("[{requestId}] Penumbra.GetGameObjectResourcePaths finished in {elapsedMs}ms (null: {isNull})",
+            requestId, totalTimer.ElapsedMilliseconds, result is null);
+
+        return result;
+    }
+
+    public string GetMetaManipulations()
+        => IsAvailable ? _getPlayerMetaManipulations.Invoke() : string.Empty;
+
+    public async Task<(string[] forward, string[][] reverse)> ResolvePathsAsync(string[] forwardPaths, string[] reversePaths)
+    {
+        if (!IsAvailable)
+        {
+            return (Array.Empty<string>(), Array.Empty<string[]>());
+        }
+
+        return await _resolvePlayerPaths.Invoke(forwardPaths, reversePaths).ConfigureAwait(false);
+    }
+
+    public string ResolveGameObjectPath(string gamePath, int gameObjectIndex)
+        => IsAvailable ? _resolveGameObjectPath.Invoke(gamePath, gameObjectIndex) : gamePath;
+
+    public string[] ReverseResolveGameObjectPath(string moddedPath, int gameObjectIndex)
+        => IsAvailable ? _reverseResolveGameObjectPath.Invoke(moddedPath, gameObjectIndex) : Array.Empty<string>();
+
+    private void HandleResourceLoaded(nint ptr, string gamePath, string resolvedPath)
+    {
+        if (ptr != nint.Zero && string.Compare(gamePath, resolvedPath, ignoreCase: true, CultureInfo.InvariantCulture) != 0)
+        {
+            Mediator.Publish(new PenumbraResourceLoadMessage(ptr, gamePath, resolvedPath));
+        }
+    }
+
+    protected override void HandleStateChange(IpcConnectionState previous, IpcConnectionState current)
+    {
+    }
+
+    public override void Dispose()
+    {
+        base.Dispose();
+        _gameObjectResourcePathResolved.Dispose();
+    }
+}

LightlessSync/Interop/Ipc/Penumbra/PenumbraTexture.cs

@@ -0,0 +1,121 @@
+using Dalamud.Plugin;
+using LightlessSync.Interop.Ipc.Framework;
+using LightlessSync.Services;
+using LightlessSync.Services.Mediator;
+using Microsoft.Extensions.Logging;
+using Penumbra.Api.Enums;
+using Penumbra.Api.IpcSubscribers;
+
+namespace LightlessSync.Interop.Ipc.Penumbra;
+
+public sealed class PenumbraTexture : PenumbraBase
+{
+    private readonly PenumbraRedraw _redrawFeature;
+    private readonly ConvertTextureFile _convertTextureFile;
+
+    public PenumbraTexture(
+        ILogger logger,
+        IDalamudPluginInterface pluginInterface,
+        DalamudUtilService dalamudUtil,
+        LightlessMediator mediator,
+        PenumbraRedraw redrawFeature) : base(logger, pluginInterface, dalamudUtil, mediator)
+    {
+        _redrawFeature = redrawFeature;
+        _convertTextureFile = new ConvertTextureFile(pluginInterface);
+    }
+
+    public override string Name => "Penumbra.Textures";
+
+    public async Task ConvertTextureFilesAsync(ILogger logger, IReadOnlyList<TextureConversionJob> jobs, IProgress<TextureConversionProgress>? progress, CancellationToken token, bool requestRedraw)
+    {
+        if (!IsAvailable || jobs.Count == 0)
+        {
+            return;
+        }
+
+        Mediator.Publish(new HaltScanMessage(nameof(ConvertTextureFilesAsync)));
+
+        var totalJobs = jobs.Count;
+        var completedJobs = 0;
+
+        try
+        {
+            foreach (var job in jobs)
+            {
+                if (token.IsCancellationRequested)
+                {
+                    break;
+                }
+
+                progress?.Report(new TextureConversionProgress(completedJobs, totalJobs, job));
+                await ConvertSingleJobAsync(logger, job, token).ConfigureAwait(false);
+                completedJobs++;
+            }
+        }
+        finally
+        {
+            Mediator.Publish(new ResumeScanMessage(nameof(ConvertTextureFilesAsync)));
+        }
+
+        if (requestRedraw && completedJobs > 0 && !token.IsCancellationRequested)
+        {
+            await DalamudUtil.RunOnFrameworkThread(async () =>
+            {
+                var player = await DalamudUtil.GetPlayerPointerAsync().ConfigureAwait(false);
+                if (player == null)
+                {
+                    return;
+                }
+
+                var gameObject = await DalamudUtil.CreateGameObjectAsync(player).ConfigureAwait(false);
+                if (gameObject == null)
+                {
+                    return;
+                }
+
+                _redrawFeature.RequestImmediateRedraw(gameObject.ObjectIndex, RedrawType.Redraw);
+            }).ConfigureAwait(false);
+        }
+    }
+
+    public async Task ConvertTextureFileDirectAsync(TextureConversionJob job, CancellationToken token)
+    {
+        if (!IsAvailable)
+        {
+            return;
+        }
+
+        await ConvertSingleJobAsync(Logger, job, token).ConfigureAwait(false);
+    }
+
+    private async Task ConvertSingleJobAsync(ILogger logger, TextureConversionJob job, CancellationToken token)
+    {
+        token.ThrowIfCancellationRequested();
+
+        logger.LogInformation("Converting texture {Input} -> {Output} ({Target})", job.InputFile, job.OutputFile, job.TargetType);
+        var convertTask = _convertTextureFile.Invoke(job.InputFile, job.OutputFile, job.TargetType, job.IncludeMipMaps);
+        await convertTask.ConfigureAwait(false);
+
+        if (!convertTask.IsCompletedSuccessfully || job.DuplicateTargets is not { Count: > 0 })
+        {
+            return;
+        }
+
+        foreach (var duplicate in job.DuplicateTargets)
+        {
+            try
+            {
+                logger.LogInformation("Synchronizing duplicate {Duplicate}", duplicate);
+                File.Copy(job.OutputFile, duplicate, overwrite: true);
+            }
+            catch (Exception ex)
+            {
+                logger.LogError(ex, "Failed to copy duplicate {Duplicate}", duplicate);
+            }
+        }
+    }
+
+    protected override void HandleStateChange(IpcConnectionState previous, IpcConnectionState current)
+    {
+    }
+}

LightlessSync/Interop/Ipc/TextureConversionJob.cs

@@ -0,0 +1,21 @@
+using Penumbra.Api.Enums;
+
+namespace LightlessSync.Interop.Ipc;
+
+/// <summary>
+///     Represents a single texture conversion request, including optional duplicate targets.
+/// </summary>
+public sealed record TextureConversionJob(
+    string InputFile,
+    string OutputFile,
+    TextureType TargetType,
+    bool IncludeMipMaps = true,
+    IReadOnlyList<string>? DuplicateTargets = null);
+
+/// <summary>
+///     Progress payload for a texture conversion batch.
+/// </summary>
+/// <param name="Completed">Number of completed conversions.</param>
+/// <param name="Total">Total number of conversions scheduled.</param>
+/// <param name="CurrentJob">The job currently being processed.</param>
+public sealed record TextureConversionProgress(int Completed, int Total, TextureConversionJob CurrentJob);

LightlessSync/LightlessConfiguration/ChatConfigService.cs

@@ -0,0 +1,14 @@
+using LightlessSync.LightlessConfiguration.Configurations;
+
+namespace LightlessSync.LightlessConfiguration;
+
+public sealed class ChatConfigService : ConfigurationServiceBase<ChatConfig>
+{
+    public const string ConfigName = "chatconfig.json";
+
+    public ChatConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

LightlessSync/LightlessConfiguration/ConfigurationMigrator.cs

@@ -19,6 +19,27 @@ public class ConfigurationMigrator(ILogger<ConfigurationMigrator> logger, Transi
             transientConfigService.Save();
         }
 
+        if (transientConfigService.Current.Version == 1)
+        {
+            _logger.LogInformation("Migrating Transient Config V1 => V2");
+            var totalRemoved = 0;
+            var configCount = 0;
+            var changedCount = 0;
+            foreach (var config in transientConfigService.Current.TransientConfigs.Values)
+            {
+                if (config.NormalizePaths(out var removed))
+                    changedCount++;
+
+                totalRemoved += removed;
+
+                configCount++;
+            }
+
+            _logger.LogInformation("Transient config normalization: processed {count} entries, updated {updated}, removed {removed} paths", configCount, changedCount, totalRemoved);
+            transientConfigService.Current.Version = 2;
+            transientConfigService.Save();
+        }
+
         if (serverConfigService.Current.Version == 1)
         {
             _logger.LogInformation("Migrating Server Config V1 => V2");

LightlessSync/LightlessConfiguration/ConfigurationSaveService.cs

@@ -1,5 +1,4 @@
 using LightlessSync.LightlessConfiguration.Configurations;
-using LightlessSync.LightlessConfiguration;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
 using System.Reflection;

LightlessSync/LightlessConfiguration/Configurations/ChatConfig.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+[Serializable]
+public sealed class ChatConfig : ILightlessConfiguration
+{
+    public int Version { get; set; } = 1;
+    public bool AutoEnableChatOnLogin { get; set; } = false;
+    public bool ShowRulesOverlayOnOpen { get; set; } = true;
+    public bool ShowMessageTimestamps { get; set; } = true;
+    public bool ShowNotesInSyncshellChat { get; set; } = true;
+    public bool EnableAnimatedEmotes { get; set; } = true;
+    public float EmoteScale { get; set; } = 1.5f;
+    public bool EnableMentionNotifications { get; set; } = true;
+    public bool AutoOpenChatOnNewMessage { get; set; } = false;
+    public float ChatWindowOpacity { get; set; } = .97f;
+    public bool FadeWhenUnfocused { get; set; } = false;
+    public float UnfocusedWindowOpacity { get; set; } = 0.6f;
+    public bool IsWindowPinned { get; set; } = false;
+    public bool AutoOpenChatOnPluginLoad { get; set; } = false;
+    public float ChatFontScale { get; set; } = 1.0f;
+    public bool HideInCombat { get; set; } = false;
+    public bool HideInDuty { get; set; } = false;
+    public bool ShowWhenUiHidden { get; set; } = true;
+    public bool ShowInCutscenes { get; set; } = true;
+    public bool ShowInGpose { get; set; } = true;
+    public bool PersistSyncshellHistory { get; set; } = false;
+    public List<string> ChannelOrder { get; set; } = new();
+    public Dictionary<string, bool> HiddenChannels { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, string> SyncshellChannelHistory { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, bool> PreferNotesForChannels { get; set; } = new(StringComparer.Ordinal);
+}

LightlessSync/LightlessConfiguration/Configurations/LightfinderDtrDisplayMode.cs

@@ -0,0 +1,7 @@
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+public enum LightfinderDtrDisplayMode
+{
+    NearbyBroadcasts = 0,
+    PendingPairRequests = 1,
+}

LightlessSync/LightlessConfiguration/Configurations/LightlessConfig.cs

@@ -0,0 +1,168 @@
+using Dalamud.Game.Text;
+using LightlessSync.UtilsEnum.Enum;
+using LightlessSync.LightlessConfiguration.Models;
+using LightlessSync.UI;
+using LightlessSync.UI.Models;
+using Microsoft.Extensions.Logging;
+using LightlessSync.PlayerData.Factories;
+
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+[Serializable]
+public class LightlessConfig : ILightlessConfiguration
+{
+    public bool AcceptedAgreement { get; set; } = false;
+    public string CacheFolder { get; set; } = string.Empty;
+    public bool DisableOptionalPluginWarnings { get; set; } = false;
+    public bool EnableDtrEntry { get; set; } = false;
+    public bool ShowUidInDtrTooltip { get; set; } = true;
+    public bool PreferNoteInDtrTooltip { get; set; } = false;
+    public bool IsNameplateColorsEnabled { get; set; } = false;
+    public DtrEntry.Colors NameplateColors { get; set; } = new(Foreground: 0xE69138u, Glow: 0xFFBA47u);
+    public Dictionary<string, string> CustomUIColors { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    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 ShowLightfinderInDtr { get; set; } = false;
+    public bool UseLightfinderColorsInDtr { get; set; } = true;
+    public DtrEntry.Colors DtrColorsLightfinderEnabled { get; set; } = new(Foreground: 0xB590FFu, Glow: 0x4F406Eu);
+    public DtrEntry.Colors DtrColorsLightfinderDisabled { get; set; } = new(Foreground: 0xD44444u, Glow: 0x642222u);
+    public DtrEntry.Colors DtrColorsLightfinderCooldown { get; set; } = new(Foreground: 0xFFE97Au, Glow: 0x766C3Au);
+    public DtrEntry.Colors DtrColorsLightfinderUnavailable { get; set; } = new(Foreground: 0x000000u, Glow: 0x000000u);
+    public LightfinderDtrDisplayMode LightfinderDtrDisplayMode { get; set; } = LightfinderDtrDisplayMode.PendingPairRequests;
+    public bool UseLightlessRedesign { get; set; } = true;
+    public bool ShowUiWhenUiHidden { get; set; } = true;
+    public bool ShowUiInGpose { get; set; } = true;
+    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 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 ParallelUploads { get; set; } = 8;
+    public bool EnablePairProcessingLimiter { get; set; } = true;
+    public int MaxConcurrentPairApplications { get; set; } = 3;
+    public int DownloadSpeedLimitInBytes { get; set; } = 0;
+    public DownloadSpeeds DownloadSpeedType { get; set; } = DownloadSpeeds.MBps;
+    public bool PreferNotesOverNamesForVisible { get; set; } = false;
+    public VisiblePairSortMode VisiblePairSortMode { get; set; } = VisiblePairSortMode.Alphabetical;
+    public OnlinePairSortMode OnlinePairSortMode { get; set; } = OnlinePairSortMode.Alphabetical;
+    public TextureFormatSortMode TextureFormatSortMode { get; set; } = TextureFormatSortMode.None;
+    public float ProfileDelay { get; set; } = 1.5f;
+    public bool ProfilePopoutRight { get; set; } = false;
+    public bool ProfilesAllowNsfw { get; set; } = false;
+    public bool ProfilesShow { get; set; } = true;
+    public bool ShowSyncshellUsersInVisible { get; set; } = true;
+    public bool ShowCharacterNameInsteadOfNotesForVisible { get; set; } = false;
+    public bool ShowOfflineUsersSeparately { get; set; } = true;
+    public bool ShowSyncshellOfflineUsersSeparately { get; set; } = true;
+    public bool ShowGroupedSyncshellsInAll { get; set; } = true;
+    public bool GroupUpSyncshells { get; set; } = true;
+    public bool ShowOnlineNotifications { get; set; } = false;
+    public bool ShowOnlineNotificationsOnlyForIndividualPairs { get; set; } = true;
+    public bool ShowOnlineNotificationsOnlyForNamedPairs { get; set; } = false;
+    public bool ShowVisiblePairsGreenEye { get; set; } = false;
+    public bool ShowTransferBars { get; set; } = true;
+    public bool ShowTransferWindow { get; set; } = false;
+    public bool ShowPlayerLinesTransferWindow { get; set; } = true;
+    public bool ShowPlayerSpeedBarsTransferWindow { get; set; } = true;
+    public bool UseNotificationsForDownloads { get; set; } = true;
+    public bool ShowUploading { get; set; } = true;
+    public bool ShowUploadingBigText { get; set; } = true;
+    public bool ShowVisibleUsersSeparately { get; set; } = true;
+    public bool EnableDirectDownloads { 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 bool DebugStopWhining { get; set; } = false;
+    public bool AutoPopulateEmptyNotesFromCharaName { get; set; } = false;
+    public int Version { get; set; } = 1;
+    public NotificationLocation WarningNotification { get; set; } = NotificationLocation.Both;
+    
+    // Lightless Notification Configuration
+    public bool UseLightlessNotifications { get; set; } = true;
+    public bool ShowNotificationProgress { get; set; } = true;
+    public NotificationLocation LightlessInfoNotification { get; set; } = NotificationLocation.LightlessUi;
+    public NotificationLocation LightlessWarningNotification { get; set; } = NotificationLocation.LightlessUi;
+    public NotificationLocation LightlessErrorNotification { get; set; } = NotificationLocation.ChatAndLightlessUi;
+    public NotificationLocation LightlessPairRequestNotification { get; set; } = NotificationLocation.LightlessUi;
+    public NotificationLocation LightlessDownloadNotification { get; set; } = NotificationLocation.TextOverlay;
+    public NotificationLocation LightlessPerformanceNotification { get; set; } = NotificationLocation.LightlessUi;
+    
+    // Basic Settings
+    public float NotificationOpacity { get; set; } = 0.95f;
+    public int MaxSimultaneousNotifications { get; set; } = 5;
+    public bool AutoDismissOnAction { get; set; } = true;
+    public bool DismissNotificationOnClick { get; set; } = false;
+    public bool ShowNotificationTimestamp { get; set; } = false;
+    
+    // Position & Layout
+    public NotificationCorner NotificationCorner { get; set; } = NotificationCorner.Right;
+    public int NotificationOffsetY { get; set; } = 50;
+    public int NotificationOffsetX { get; set; } = 0;
+    public float NotificationWidth { get; set; } = 350f;
+    public float NotificationSpacing { get; set; } = 8f;
+    
+    // Animation & Effects
+    public float NotificationAnimationSpeed { get; set; } = 10f;
+    public float NotificationSlideSpeed { get; set; } = 10f;
+    public float NotificationAccentBarWidth { get; set; } = 3f;
+    
+    // Duration per Type
+    public int InfoNotificationDurationSeconds { get; set; } = 10;
+    public int WarningNotificationDurationSeconds { get; set; } = 15;
+    public int ErrorNotificationDurationSeconds { get; set; } = 20;
+    public int PairRequestDurationSeconds { get; set; } = 180;
+    public int DownloadNotificationDurationSeconds { get; set; } = 30;
+    public int PerformanceNotificationDurationSeconds { get; set; } = 20;
+    public uint CustomInfoSoundId { get; set; } = 2;  // Se2
+    public uint CustomWarningSoundId { get; set; } = 16; // Se15
+    public uint CustomErrorSoundId { get; set; } = 16; // Se15
+    public uint PairRequestSoundId { get; set; } = 5; // Se5
+    public uint PerformanceSoundId { get; set; } = 16; // Se15
+    public bool DisableInfoSound { get; set; } = true;
+    public bool DisableWarningSound { get; set; } = true;
+    public bool DisableErrorSound { get; set; } = true;
+    public bool DisablePairRequestSound { get; set; } = true;
+    public bool DisablePerformanceSound { get; set; } = true;
+    public bool ShowPerformanceNotificationActions { get; set; } = true;
+    public bool ShowPairRequestNotificationActions { get; set; } = true;
+    public bool UseFocusTarget { get; set; } = false;
+    public bool overrideFriendColor { get; set; } = false;
+    public bool overridePartyColor { get; set; } = false;
+    public bool overrideFcTagColor { get; set; } = false;
+    public bool useColoredUIDs { get; set; } = true;
+    public bool BroadcastEnabled { get; set; } = false;
+    public bool LightfinderAutoEnableOnConnect { get; set; } = false;
+    public LightfinderLabelRenderer LightfinderLabelRenderer { get; set; } = LightfinderLabelRenderer.Pictomancy;
+    public short LightfinderLabelOffsetX { get; set; } = 0;
+    public short LightfinderLabelOffsetY { get; set; } = 0;
+    public bool LightfinderLabelUseIcon { get; set; } = false;
+    public bool LightfinderLabelShowOwn { get; set; } = true;
+    public bool LightfinderLabelShowPaired { get; set; } = true;
+    public bool LightfinderLabelShowHidden { get; set; } = false;
+    public string LightfinderLabelIconGlyph { get; set; } = SeIconCharExtensions.ToIconString(SeIconChar.Hyadelyn);
+    public float LightfinderLabelScale { get; set; } = 1.0f;
+    public bool LightfinderAutoAlign { get; set; } = true;
+    public LabelAlignment LabelAlignment { get; set; } = LabelAlignment.Left;
+    public DateTime BroadcastTtl { get; set; } = DateTime.MinValue;
+    public bool SyncshellFinderEnabled { get; set; } = false;
+    public string? SelectedFinderSyncshell { get; set; } = null;
+    public string LastSeenVersion { get; set; } = string.Empty;
+    public bool EnableParticleEffects { get; set; } = true;
+    public HashSet<Guid> OrphanableTempCollections { get; set; } = [];
+    public List<OrphanableTempCollectionEntry> OrphanableTempCollectionEntries { get; set; } = [];
+    public AnimationValidationMode AnimationValidationMode { get; set; } = AnimationValidationMode.Unsafe;
+    public bool AnimationAllowOneBasedShift { get; set; } = false;
+    public bool AnimationAllowNeighborIndexTolerance { get; set; } = false;
+}

LightlessSync/LightlessConfiguration/Configurations/ModelDecimationSettings.cs

@@ -0,0 +1,156 @@
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+public static class ModelDecimationDefaults
+{
+    public const bool EnableAutoDecimation = false;
+    public const int TriangleThreshold = 15_000;
+    public const double TargetRatio = 0.8;
+    public const bool NormalizeTangents = true;
+    public const bool AvoidBodyIntersection = true;
+
+    /// <summary>Default triangle threshold for batch decimation (0 = no threshold).</summary>
+    public const int BatchTriangleThreshold = 0;
+
+    /// <summary>Default target triangle ratio for batch decimation.</summary>
+    public const double BatchTargetRatio = 0.8;
+
+    /// <summary>Default tangent normalization toggle for batch decimation.</summary>
+    public const bool BatchNormalizeTangents = true;
+
+    /// <summary>Default body collision guard toggle for batch decimation.</summary>
+    public const bool BatchAvoidBodyIntersection = true;
+
+    /// <summary>Default display for the batch decimation warning overlay.</summary>
+    public const bool ShowBatchDecimationWarning = true;
+
+    public const bool KeepOriginalModelFiles = true;
+    public const bool SkipPreferredPairs = true;
+    public const bool AllowBody = false;
+    public const bool AllowFaceHead = false;
+    public const bool AllowTail = false;
+    public const bool AllowClothing = true;
+    public const bool AllowAccessories = true;
+}
+
+public sealed class ModelDecimationAdvancedSettings
+{
+    /// <summary>Minimum triangles per connected component before skipping decimation.</summary>
+    public const int DefaultMinComponentTriangles = 6;
+
+    /// <summary>Average-edge multiplier used to cap collapses.</summary>
+    public const float DefaultMaxCollapseEdgeLengthFactor = 1.25f;
+
+    /// <summary>Maximum normal deviation (degrees) allowed for a collapse.</summary>
+    public const float DefaultNormalSimilarityThresholdDegrees = 60f;
+
+    /// <summary>Minimum bone-weight overlap required to allow a collapse.</summary>
+    public const float DefaultBoneWeightSimilarityThreshold = 0.85f;
+
+    /// <summary>UV similarity threshold to protect seams.</summary>
+    public const float DefaultUvSimilarityThreshold = 0.02f;
+
+    /// <summary>UV seam cosine threshold for blocking seam collapses.</summary>
+    public const float DefaultUvSeamAngleCos = 0.99f;
+
+    /// <summary>Whether to block UV seam vertices from collapsing.</summary>
+    public const bool DefaultBlockUvSeamVertices = true;
+
+    /// <summary>Whether to allow collapses on boundary edges.</summary>
+    public const bool DefaultAllowBoundaryCollapses = false;
+
+    /// <summary>Body collision distance factor for the primary pass.</summary>
+    public const float DefaultBodyCollisionDistanceFactor = 0.75f;
+
+    /// <summary>Body collision distance factor for the relaxed fallback pass.</summary>
+    public const float DefaultBodyCollisionNoOpDistanceFactor = 0.25f;
+
+    /// <summary>Relax multiplier applied when the mesh is close to the body.</summary>
+    public const float DefaultBodyCollisionAdaptiveRelaxFactor = 1.0f;
+
+    /// <summary>Ratio of near-body vertices required to trigger relaxation.</summary>
+    public const float DefaultBodyCollisionAdaptiveNearRatio = 0.4f;
+
+    /// <summary>UV threshold for relaxed body-collision mode.</summary>
+    public const float DefaultBodyCollisionAdaptiveUvThreshold = 0.08f;
+
+    /// <summary>UV seam cosine threshold for relaxed body-collision mode.</summary>
+    public const float DefaultBodyCollisionNoOpUvSeamAngleCos = 0.98f;
+
+    /// <summary>Expansion factor for protected vertices near the body.</summary>
+    public const float DefaultBodyCollisionProtectionFactor = 1.5f;
+
+    /// <summary>Minimum ratio used when decimating the body proxy.</summary>
+    public const float DefaultBodyProxyTargetRatioMin = 0.85f;
+
+    /// <summary>Inflation applied to body collision distances.</summary>
+    public const float DefaultBodyCollisionProxyInflate = 0.0005f;
+
+    /// <summary>Body collision penetration factor used during collapse checks.</summary>
+    public const float DefaultBodyCollisionPenetrationFactor = 0.75f;
+
+    /// <summary>Minimum body collision distance threshold.</summary>
+    public const float DefaultMinBodyCollisionDistance = 0.0001f;
+
+    /// <summary>Minimum cell size for body collision spatial hashing.</summary>
+    public const float DefaultMinBodyCollisionCellSize = 0.0001f;
+
+    /// <summary>Minimum triangles per connected component before skipping decimation.</summary>
+    public int MinComponentTriangles { get; set; } = DefaultMinComponentTriangles;
+
+    /// <summary>Average-edge multiplier used to cap collapses.</summary>
+    public float MaxCollapseEdgeLengthFactor { get; set; } = DefaultMaxCollapseEdgeLengthFactor;
+
+    /// <summary>Maximum normal deviation (degrees) allowed for a collapse.</summary>
+    public float NormalSimilarityThresholdDegrees { get; set; } = DefaultNormalSimilarityThresholdDegrees;
+
+    /// <summary>Minimum bone-weight overlap required to allow a collapse.</summary>
+    public float BoneWeightSimilarityThreshold { get; set; } = DefaultBoneWeightSimilarityThreshold;
+
+    /// <summary>UV similarity threshold to protect seams.</summary>
+    public float UvSimilarityThreshold { get; set; } = DefaultUvSimilarityThreshold;
+
+    /// <summary>UV seam cosine threshold for blocking seam collapses.</summary>
+    public float UvSeamAngleCos { get; set; } = DefaultUvSeamAngleCos;
+
+    /// <summary>Whether to block UV seam vertices from collapsing.</summary>
+    public bool BlockUvSeamVertices { get; set; } = DefaultBlockUvSeamVertices;
+
+    /// <summary>Whether to allow collapses on boundary edges.</summary>
+    public bool AllowBoundaryCollapses { get; set; } = DefaultAllowBoundaryCollapses;
+
+    /// <summary>Body collision distance factor for the primary pass.</summary>
+    public float BodyCollisionDistanceFactor { get; set; } = DefaultBodyCollisionDistanceFactor;
+
+    /// <summary>Body collision distance factor for the relaxed fallback pass.</summary>
+    public float BodyCollisionNoOpDistanceFactor { get; set; } = DefaultBodyCollisionNoOpDistanceFactor;
+
+    /// <summary>Relax multiplier applied when the mesh is close to the body.</summary>
+    public float BodyCollisionAdaptiveRelaxFactor { get; set; } = DefaultBodyCollisionAdaptiveRelaxFactor;
+
+    /// <summary>Ratio of near-body vertices required to trigger relaxation.</summary>
+    public float BodyCollisionAdaptiveNearRatio { get; set; } = DefaultBodyCollisionAdaptiveNearRatio;
+
+    /// <summary>UV threshold for relaxed body-collision mode.</summary>
+    public float BodyCollisionAdaptiveUvThreshold { get; set; } = DefaultBodyCollisionAdaptiveUvThreshold;
+
+    /// <summary>UV seam cosine threshold for relaxed body-collision mode.</summary>
+    public float BodyCollisionNoOpUvSeamAngleCos { get; set; } = DefaultBodyCollisionNoOpUvSeamAngleCos;
+
+    /// <summary>Expansion factor for protected vertices near the body.</summary>
+    public float BodyCollisionProtectionFactor { get; set; } = DefaultBodyCollisionProtectionFactor;
+
+    /// <summary>Minimum ratio used when decimating the body proxy.</summary>
+    public float BodyProxyTargetRatioMin { get; set; } = DefaultBodyProxyTargetRatioMin;
+
+    /// <summary>Inflation applied to body collision distances.</summary>
+    public float BodyCollisionProxyInflate { get; set; } = DefaultBodyCollisionProxyInflate;
+
+    /// <summary>Body collision penetration factor used during collapse checks.</summary>
+    public float BodyCollisionPenetrationFactor { get; set; } = DefaultBodyCollisionPenetrationFactor;
+
+    /// <summary>Minimum body collision distance threshold.</summary>
+    public float MinBodyCollisionDistance { get; set; } = DefaultMinBodyCollisionDistance;
+
+    /// <summary>Minimum cell size for body collision spatial hashing.</summary>
+    public float MinBodyCollisionCellSize { get; set; } = DefaultMinBodyCollisionCellSize;
+}

LightlessSync/LightlessConfiguration/Configurations/PairTagStorage.cs

@@ -0,0 +1,7 @@
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+public class PairTagStorage : ILightlessConfiguration
+{
+    public Dictionary<string, Models.PairTagStorage> ServerTagStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public int Version { get; set; } = 0;
+}

LightlessSync/LightlessConfiguration/Configurations/PlayerPerformanceConfig.cs

@@ -0,0 +1,46 @@
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+public class PlayerPerformanceConfig : ILightlessConfiguration
+{
+    public int Version { get; set; } = 1;
+    public bool ShowPerformanceIndicator { get; set; } = true;
+    public bool ShowPerformanceUsageNextToName { get; set; } = false;
+    public bool WarnOnExceedingThresholds { get; set; } = true;
+    public bool WarnOnPreferredPermissionsExceedingThresholds { get; set; } = false;
+    public int VRAMSizeWarningThresholdMiB { get; set; } = 375;
+    public int TrisWarningThresholdThousands { get; set; } = 165;
+    public bool AutoPausePlayersExceedingThresholds { get; set; } = false;
+    public bool AutoPausePlayersWithPreferredPermissionsExceedingThresholds { get; set; } = false;
+    public int VRAMSizeAutoPauseThresholdMiB { get; set; } = 550;
+    public int TrisAutoPauseThresholdThousands { get; set; } = 250;
+    public List<string> UIDsToIgnore { get; set; } = new();
+    public bool PauseInInstanceDuty { get; set; } = false;
+    public bool PauseWhilePerforming { get; set; } = true;
+    public bool PauseInCombat { get; set; } = true;
+    public bool EnableNonIndexTextureMipTrim { get; set; } = false;
+    public bool EnableIndexTextureDownscale { get; set; } = false;
+    public int TextureDownscaleMaxDimension { get; set; } = 2048;
+    public bool OnlyDownscaleUncompressedTextures { get; set; } = true;
+    public bool EnableUncompressedTextureCompression { get; set; } = false;
+    public bool SkipUncompressedTextureCompressionMipMaps { get; set; } = false;
+    public bool KeepOriginalTextureFiles { get; set; } = false;
+    public bool SkipTextureDownscaleForPreferredPairs { get; set; } = true;
+    public bool EnableModelDecimation { get; set; } = ModelDecimationDefaults.EnableAutoDecimation;
+    public int ModelDecimationTriangleThreshold { get; set; } = ModelDecimationDefaults.TriangleThreshold;
+    public double ModelDecimationTargetRatio { get; set; } = ModelDecimationDefaults.TargetRatio;
+    public bool ModelDecimationNormalizeTangents { get; set; } = ModelDecimationDefaults.NormalizeTangents;
+    public bool ModelDecimationAvoidBodyIntersection { get; set; } = ModelDecimationDefaults.AvoidBodyIntersection;
+    public ModelDecimationAdvancedSettings ModelDecimationAdvanced { get; set; } = new();
+    public int BatchModelDecimationTriangleThreshold { get; set; } = ModelDecimationDefaults.BatchTriangleThreshold;
+    public double BatchModelDecimationTargetRatio { get; set; } = ModelDecimationDefaults.BatchTargetRatio;
+    public bool BatchModelDecimationNormalizeTangents { get; set; } = ModelDecimationDefaults.BatchNormalizeTangents;
+    public bool BatchModelDecimationAvoidBodyIntersection { get; set; } = ModelDecimationDefaults.BatchAvoidBodyIntersection;
+    public bool ShowBatchModelDecimationWarning { get; set; } = ModelDecimationDefaults.ShowBatchDecimationWarning;
+    public bool KeepOriginalModelFiles { get; set; } = ModelDecimationDefaults.KeepOriginalModelFiles;
+    public bool SkipModelDecimationForPreferredPairs { get; set; } = ModelDecimationDefaults.SkipPreferredPairs;
+    public bool ModelDecimationAllowBody { get; set; } = ModelDecimationDefaults.AllowBody;
+    public bool ModelDecimationAllowFaceHead { get; set; } = ModelDecimationDefaults.AllowFaceHead;
+    public bool ModelDecimationAllowTail { get; set; } = ModelDecimationDefaults.AllowTail;
+    public bool ModelDecimationAllowClothing { get; set; } = ModelDecimationDefaults.AllowClothing;
+    public bool ModelDecimationAllowAccessories { get; set; } = ModelDecimationDefaults.AllowAccessories;
+}

LightlessSync/LightlessConfiguration/Configurations/SyncshellTagStorage.cs

@@ -0,0 +1,7 @@
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+public class SyncshellTagStorage : ILightlessConfiguration
+{
+    public Dictionary<string, Models.SyncshellTagStorage> ServerTagStorage { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public int Version { get; set; } = 0;
+}

LightlessSync/LightlessConfiguration/Configurations/TransientConfig.cs

@@ -0,0 +1,157 @@
+using LightlessSync.API.Data.Enum;
+
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+public class TransientConfig : ILightlessConfiguration
+{
+    public Dictionary<string, TransientPlayerConfig> TransientConfigs { get; set; } = [];
+    public int Version { get; set; } = 2;
+
+    public class TransientPlayerConfig
+    {
+        public List<string> GlobalPersistentCache { get; set; } = [];
+        public Dictionary<uint, List<string>> JobSpecificCache { get; set; } = [];
+        public Dictionary<uint, List<string>> JobSpecificPetCache { get; set; } = [];
+
+        private readonly object _cacheLock = new();
+
+        public TransientPlayerConfig()
+        {
+
+        }
+
+        private bool ElevateIfNeeded(uint jobId, string gamePath)
+        {
+            // check if it's in the job cache of other jobs and elevate if needed
+            foreach (var kvp in JobSpecificCache)
+            {
+                if (kvp.Key == jobId) continue;
+
+                // elevate if the gamepath is included somewhere else
+                if (kvp.Value.Contains(gamePath, StringComparer.Ordinal))
+                {
+                    JobSpecificCache[kvp.Key].Remove(gamePath);
+                    GlobalPersistentCache.Add(gamePath);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public int RemovePath(string gamePath, ObjectKind objectKind)
+        {
+            lock (_cacheLock)
+            {
+                int removedEntries = 0;
+                if (objectKind == ObjectKind.Player)
+                {
+                    if (GlobalPersistentCache.Remove(gamePath)) removedEntries++;
+                    foreach (var kvp in JobSpecificCache)
+                    {
+                        if (kvp.Value.Remove(gamePath)) removedEntries++;
+                    }
+                }
+                if (objectKind == ObjectKind.Pet)
+                {
+                    foreach (var kvp in JobSpecificPetCache)
+                    {
+                        if (kvp.Value.Remove(gamePath)) removedEntries++;
+                    }
+                }
+                return removedEntries;
+            }
+        }
+
+        public void AddOrElevate(uint jobId, string gamePath)
+        {
+            lock (_cacheLock)
+            {
+                // check if it's in the global cache, if yes, do nothing
+                if (GlobalPersistentCache.Contains(gamePath, StringComparer.Ordinal))
+                {
+                    return;
+                }
+
+                if (ElevateIfNeeded(jobId, gamePath)) return;
+
+                // check if the jobid is already in the cache to start
+                if (!JobSpecificCache.TryGetValue(jobId, out var jobCache))
+                {
+                    JobSpecificCache[jobId] = jobCache = new();
+                }
+
+                // check if the path is already in the job specific cache
+                if (!jobCache.Contains(gamePath, StringComparer.Ordinal))
+                {
+                    jobCache.Add(gamePath);
+                }
+            }
+        }
+
+        public bool NormalizePaths(out int removedEntries)
+        {
+            bool changed = false;
+            removedEntries = 0;
+
+            GlobalPersistentCache = NormalizeList(GlobalPersistentCache, ref changed, ref removedEntries);
+
+            foreach (var jobId in JobSpecificCache.Keys.ToList())
+            {
+                JobSpecificCache[jobId] = NormalizeList(JobSpecificCache[jobId], ref changed, ref removedEntries);
+            }
+
+            foreach (var jobId in JobSpecificPetCache.Keys.ToList())
+            {
+                JobSpecificPetCache[jobId] = NormalizeList(JobSpecificPetCache[jobId], ref changed, ref removedEntries);
+            }
+
+            return changed;
+        }
+
+        private static List<string> NormalizeList(List<string> entries, ref bool changed, ref int removedEntries)
+        {
+            if (entries.Count == 0)
+                return entries;
+
+            var result = new List<string>(entries.Count);
+            var seen = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var entry in entries)
+            {
+                var normalized = NormalizePath(entry);
+                if (string.IsNullOrEmpty(normalized))
+                {
+                    changed = true;
+                    continue;
+                }
+
+                if (!string.Equals(entry, normalized, StringComparison.Ordinal))
+                {
+                    changed = true;
+                }
+
+                if (seen.Add(normalized))
+                {
+                    result.Add(normalized);
+                }
+                else
+                {
+                    changed = true;
+                }
+            }
+
+            removedEntries += entries.Count - result.Count;
+
+            return result;
+        }
+
+        private static string NormalizePath(string path)
+        {
+            if (string.IsNullOrEmpty(path))
+                return string.Empty;
+
+            return path.Replace("\\", "/", StringComparison.Ordinal).ToLowerInvariant();
+        }
+    }
+}

LightlessSync/LightlessConfiguration/Configurations/UiStyleOverride.cs

@@ -0,0 +1,21 @@
+using System;
+using System.Numerics;
+
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+[Serializable]
+public class UiStyleOverride
+{
+    public uint? Color { get; set; }
+    public float? Float { get; set; }
+    public Vector2Config? Vector2 { get; set; }
+
+    public bool IsEmpty => Color is null && Float is null && Vector2 is null;
+}
+
+[Serializable]
+public record struct Vector2Config(float X, float Y)
+{
+    public static implicit operator Vector2(Vector2Config value) => new(value.X, value.Y);
+    public static implicit operator Vector2Config(Vector2 value) => new(value.X, value.Y);
+}

LightlessSync/LightlessConfiguration/Configurations/UiThemeConfig.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+
+namespace LightlessSync.LightlessConfiguration.Configurations;
+
+[Serializable]
+public class UiThemeConfig : ILightlessConfiguration
+{
+    public Dictionary<string, UiStyleOverride> StyleOverrides { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+
+    public int Version { get; set; } = 1;
+}

LightlessSync/LightlessConfiguration/Configurations/XivDataStorageConfig.cs

@@ -5,6 +5,7 @@ namespace LightlessSync.LightlessConfiguration.Configurations;
 public class XivDataStorageConfig : ILightlessConfiguration
 {
     public ConcurrentDictionary<string, long> TriangleDictionary { get; set; } = new(StringComparer.OrdinalIgnoreCase);
+    public ConcurrentDictionary<string, long> EffectiveTriangleDictionary { get; set; } = new(StringComparer.OrdinalIgnoreCase);
     public ConcurrentDictionary<string, Dictionary<string, List<ushort>>> BonesDictionary { get; set; } = new(StringComparer.OrdinalIgnoreCase);
     public int Version { get; set; } = 0;
 }

LightlessSync/LightlessConfiguration/Models/NotificationLocation.cs

@@ -0,0 +1,28 @@
+namespace LightlessSync.LightlessConfiguration.Models;
+
+public enum NotificationLocation
+{
+    Nowhere,
+    Chat,
+    Toast,
+    Both,
+    LightlessUi,
+    ChatAndLightlessUi,
+    TextOverlay,
+}
+
+public enum NotificationType
+{
+    Info,
+    Warning,
+    Error,
+    PairRequest,
+    Download,
+    Performance
+}
+
+public enum NotificationCorner
+{
+    Right,
+    Left
+}

LightlessSync/LightlessConfiguration/Models/OrphanableTempCollectionEntry.cs

@@ -0,0 +1,7 @@
+namespace LightlessSync.LightlessConfiguration.Models;
+
+public sealed class OrphanableTempCollectionEntry
+{
+    public Guid Id { get; set; }
+    public DateTime RegisteredAtUtc { get; set; } = DateTime.MinValue;
+}

LightlessSync/LightlessConfiguration/Models/PairTagStorage.cs

@@ -0,0 +1,9 @@
+namespace LightlessSync.LightlessConfiguration.Models;
+
+[Serializable]
+public class PairTagStorage
+{
+    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);
+}

LightlessSync/LightlessConfiguration/Models/ServerStorage.cs

@@ -13,5 +13,4 @@ public class ServerStorage
     public bool UseOAuth2 { get; set; } = false;
     public string? OAuthToken { get; set; } = null;
     public HttpTransportType HttpTransportType { get; set; } = HttpTransportType.WebSockets;
-    public bool ForceWebSockets { get; set; } = false;
 }

LightlessSync/LightlessConfiguration/Models/SyncshellTagStorage.cs

@@ -0,0 +1,8 @@
+namespace LightlessSync.LightlessConfiguration.Models;
+
+[Serializable]
+public class SyncshellTagStorage
+{
+    public HashSet<string> ServerAvailableSyncshellTags { get; set; } = new(StringComparer.Ordinal);
+    public Dictionary<string, List<string>> SyncshellPairedTags { get; set; } = new(StringComparer.Ordinal);
+}

LightlessSync/LightlessConfiguration/PairTagConfigService.cs

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

LightlessSync/LightlessConfiguration/SyncshellTagConfigService.cs

@@ -0,0 +1,14 @@
+using LightlessSync.LightlessConfiguration.Configurations;
+
+namespace LightlessSync.LightlessConfiguration;
+
+public class SyncshellTagConfigService : ConfigurationServiceBase<SyncshellTagStorage>
+{
+    public const string ConfigName = "syncshelltags.json";
+
+    public SyncshellTagConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

LightlessSync/LightlessConfiguration/UiThemeConfigService.cs

@@ -0,0 +1,14 @@
+using LightlessSync.LightlessConfiguration.Configurations;
+
+namespace LightlessSync.LightlessConfiguration;
+
+public class UiThemeConfigService : ConfigurationServiceBase<UiThemeConfig>
+{
+    public const string ConfigName = "ui-theme.json";
+
+    public UiThemeConfigService(string configDir) : base(configDir)
+    {
+    }
+
+    public override string ConfigurationName => ConfigName;
+}

LightlessSync/LightlessPlugin.cs

@@ -1,13 +1,15 @@
-using LightlessSync.FileCache;
+using LightlessSync.FileCache;
 using LightlessSync.LightlessConfiguration;
 using LightlessSync.PlayerData.Pairs;
 using LightlessSync.PlayerData.Services;
 using LightlessSync.Services;
 using LightlessSync.Services.Mediator;
 using LightlessSync.Services.ServerConfiguration;
+using LightlessSync.UI;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
+using Serilog;
 using System.Reflection;
 
 namespace LightlessSync;
@@ -72,6 +74,7 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService
     private readonly DalamudUtilService _dalamudUtil;
     private readonly LightlessConfigService _lightlessConfigService;
     private readonly ServerConfigurationManager _serverConfigurationManager;
+    private readonly PairHandlerRegistry _pairHandlerRegistry;
     private readonly IServiceScopeFactory _serviceScopeFactory;
     private IServiceScope? _runtimeServiceScope;
     private Task? _launchTask = null;
@@ -79,11 +82,13 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService
     public LightlessPlugin(ILogger<LightlessPlugin> logger, LightlessConfigService lightlessConfigService,
         ServerConfigurationManager serverConfigurationManager,
         DalamudUtilService dalamudUtil,
+        PairHandlerRegistry pairHandlerRegistry,
         IServiceScopeFactory serviceScopeFactory, LightlessMediator mediator) : base(logger, mediator)
     {
         _lightlessConfigService = lightlessConfigService;
         _serverConfigurationManager = serverConfigurationManager;
         _dalamudUtil = dalamudUtil;
+        _pairHandlerRegistry = pairHandlerRegistry;
         _serviceScopeFactory = serviceScopeFactory;
     }
 
@@ -98,6 +103,7 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService
         Mediator.Subscribe<DalamudLoginMessage>(this, (_) => DalamudUtilOnLogIn());
         Mediator.Subscribe<DalamudLogoutMessage>(this, (_) => DalamudUtilOnLogOut());
 
+        UIColors.Initialize(_lightlessConfigService);
         Mediator.StartQueueProcessing();
         
         return Task.CompletedTask;
@@ -105,15 +111,41 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService
 
     public Task StopAsync(CancellationToken cancellationToken)
     {
+        Logger.LogDebug("Halting LightlessPlugin");
+        try
+        {
+            _pairHandlerRegistry.ResetAllHandlers();
+        }
+        catch (Exception ex)
+        {
+            Logger.LogWarning(ex, "Failed to reset pair handlers on shutdown");
+        }
+
         UnsubscribeAll();
 
         DalamudUtilOnLogOut();
 
-        Logger.LogDebug("Halting LightlessPlugin");
-
         return Task.CompletedTask;
     }
     
+    private void CheckVersion()
+    {
+        var ver = Assembly.GetExecutingAssembly().GetName().Version;
+        var currentVersion = ver == null ? string.Empty : $"{ver.Major}.{ver.Minor}.{ver.Build}";
+        var lastSeen = _lightlessConfigService.Current.LastSeenVersion ?? string.Empty;
+        Logger.LogInformation("Last seen version: {lastSeen}, current version: {currentVersion}", lastSeen, currentVersion);
+        Logger.LogInformation("User has valid setup: {hasValidSetup}", _lightlessConfigService.Current.HasValidSetup());
+        Logger.LogInformation("Server has valid config: {hasValidConfig}", _serverConfigurationManager.HasValidConfig());
+        // Show update notes if version has changed and user has valid setup
+        
+        if (!string.Equals(lastSeen, currentVersion, StringComparison.Ordinal) &&
+            _lightlessConfigService.Current.HasValidSetup() && 
+            _serverConfigurationManager.HasValidConfig())
+        {
+            Mediator.Publish(new UiToggleMessage(typeof(UpdateNotesUi)));
+        }
+    }
+
     private void DalamudUtilOnLogIn()
     {
         Logger?.LogDebug("Client login");
@@ -151,6 +183,8 @@ public class LightlessPlugin : MediatorSubscriberBase, IHostedService
             _runtimeServiceScope.ServiceProvider.GetRequiredService<TransientResourceManager>();
             _runtimeServiceScope.ServiceProvider.GetRequiredService<VisibleUserDataDistributor>();
             _runtimeServiceScope.ServiceProvider.GetRequiredService<NotificationService>();
+            _runtimeServiceScope.ServiceProvider.GetRequiredService<NameplateService>();
+            CheckVersion();
 
 #if !DEBUG
             if (_lightlessConfigService.Current.LogLevel != LogLevel.Information)

LightlessSync/LightlessSync.csproj

@@ -1,16 +1,16 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project Sdk="Dalamud.NET.Sdk/13.0.0">
+<?xml version="1.0" encoding="utf-8"?>
+<Project Sdk="Dalamud.NET.Sdk/14.0.1">
   <PropertyGroup>
     <Authors></Authors>
     <Company></Company>
-    <Version>1.11.0</Version>
+    <Version>2.0.2.78</Version>
     <Description></Description>
     <Copyright></Copyright>
     <PackageProjectUrl>https://github.com/Light-Public-Syncshells/LightlessClient</PackageProjectUrl>
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0-windows7.0</TargetFramework>
+    <TargetFramework>net10.0-windows7.0</TargetFramework>
     <Platforms>x64</Platforms>
     <Nullable>enable</Nullable>
     <LangVersion>latest</LangVersion>
@@ -24,29 +24,39 @@
     <Compile Remove="PlayerData\Export\**" />
     <EmbeddedResource Remove="PlayerData\Export\**" />
     <None Remove="PlayerData\Export\**" />
+    <EmbeddedResource Update="Resources\Resources.resx">
+      <Generator>PublicResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+    <Compile Update="Resources\Resources.Designer.cs">
+      <DesignTime>True</DesignTime>
+      <AutoGen>True</AutoGen>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="DalamudPackager" Version="13.0.0" />
-    <PackageReference Include="Downloader" Version="3.3.4" />
+    <PackageReference Include="Blake3" Version="2.0.0" />
+    <PackageReference Include="Brio.API" Version="3.0.1" />
+    <PackageReference Include="Downloader" Version="4.0.3" />
     <PackageReference Include="K4os.Compression.LZ4.Legacy" Version="1.3.8" />
-    <PackageReference Include="Meziantou.Analyzer" Version="2.0.189">
+    <PackageReference Include="Meziantou.Analyzer" Version="2.0.264">
       <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="Glamourer.Api" Version="2.4.0" />
-    <PackageReference Include="NReco.Logging.File" Version="1.2.2" />
-    <PackageReference Include="Penumbra.Api" Version="5.6.0" />
-    <PackageReference Include="Penumbra.String" Version="1.0.5" />
-    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.7" />
-    <PackageReference Include="SonarAnalyzer.CSharp" Version="10.7.0.110445">
+    <PackageReference Include="Microsoft.AspNetCore.SignalR.Client" Version="10.0.1" />
+    <PackageReference Include="Microsoft.AspNetCore.SignalR.Protocols.MessagePack" Version="10.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Caching.Memory" Version="10.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" Version="10.0.1" />
+    <PackageReference Include="Glamourer.Api" Version="2.8.0" />
+    <PackageReference Include="NReco.Logging.File" Version="1.3.1" />
+    <PackageReference Include="SixLabors.ImageSharp" Version="3.1.12" />
+    <PackageReference Include="SonarAnalyzer.CSharp" Version="10.17.0.131074">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.7.0" />
+    <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.15.0" />
+    <PackageReference Include="YamlDotNet" Version="16.3.0" />
   </ItemGroup>
 
   <PropertyGroup>
@@ -65,8 +75,8 @@
     <None Update="images\icon.png">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
-    <EmbeddedResource Include="Localization\de.json" />
-    <EmbeddedResource Include="Localization\fr.json" />
+    <EmbeddedResource Include="Changelog\changelog.yaml" />
+    <EmbeddedResource Include="Changelog\credits.yaml" />
   </ItemGroup>
 
   <ItemGroup>
@@ -75,6 +85,38 @@
 
   <ItemGroup>
     <ProjectReference Include="..\LightlessAPI\LightlessSyncAPI\LightlessSync.API.csproj" />
+    <ProjectReference Include="..\LightlessCompactor\LightlessCompactor.csproj" />
+    <ProjectReference Include="..\LightlessCompactorWorker\LightlessCompactorWorker.csproj" ReferenceOutputAssembly="false" />
+    <ProjectReference Include="..\Penumbra.Api\Penumbra.Api.csproj" />
+    <ProjectReference Include="..\Penumbra.GameData\Penumbra.GameData.csproj" />
+    <ProjectReference Include="..\Penumbra.String\Penumbra.String.csproj" />
+    <ProjectReference Include="..\ffxiv_pictomancy\Pictomancy\Pictomancy.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <Reference Include="OtterTex">
+      <HintPath>lib\OtterTex.dll</HintPath>
+      <Private>true</Private>
+    </Reference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Include="lib\DirectXTexC.dll">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+      <TargetPath>DirectXTexC.dll</TargetPath>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Update="DalamudPackager" Version="14.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <CompactorWorkerFiles Include="..\LightlessCompactorWorker\bin\$(Configuration)\net10.0\*.*" />
+  </ItemGroup>
+
+  <Target Name="CopyCompactorWorker" AfterTargets="Build">
+    <Copy SourceFiles="@(CompactorWorkerFiles)" DestinationFolder="$(OutputPath)" SkipUnchangedFiles="true" />
+  </Target>
+	
 </Project>

LightlessSync/LightlessSync.csproj.DotSettings

@@ -0,0 +1,3 @@
+<wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeEditing/Localization/Localizable/@EntryValue">Yes</s:String>
+	<s:String x:Key="/Default/CodeEditing/Localization/LocalizableInspector/@EntryValue">Pessimistic</s:String></wpf:ResourceDictionary>

LightlessSync/Localization/Strings.cs

@@ -1,44 +0,0 @@
-using CheapLoc;
-
-namespace LightlessSync.Localization;
-
-public static class Strings
-{
-    public static ToSStrings ToS { get; set; } = new();
-
-    public class ToSStrings
-    {
-        public readonly string AgreeLabel = Loc.Localize("AgreeLabel", "I agree");
-        public readonly string AgreementLabel = Loc.Localize("AgreementLabel", "Agreement of Usage of Service");
-        public readonly string ButtonWillBeAvailableIn = Loc.Localize("ButtonWillBeAvailableIn", "'I agree' button will be available in");
-        public readonly string LanguageLabel = Loc.Localize("LanguageLabel", "Language");
-
-        public readonly string Paragraph1 = Loc.Localize("Paragraph1",
-            "All of the mod files currently active on your character as well as your current character state will be uploaded to the service you registered yourself at automatically. " +
-            "The plugin will exclusively upload the necessary mod files and not the whole mod.");
-
-        public readonly string Paragraph2 = Loc.Localize("Paragraph2",
-            "If you are on a data capped internet connection, higher fees due to data usage depending on the amount of downloaded and uploaded mod files might occur. " +
-            "Mod files will be compressed on up- and download to save on bandwidth usage. Due to varying up- and download speeds, changes in characters might not be visible immediately. " +
-            "Files present on the service that already represent your active mod files will not be uploaded again.");
-
-        public readonly string Paragraph3 = Loc.Localize("Paragraph3",
-            "The mod files you are uploading are confidential and will not be distributed to parties other than the ones who are requesting the exact same mod files. " +
-            "Please think about who you are going to pair since it is unavoidable that they will receive and locally cache the necessary mod files that you have currently in use. " +
-            "Locally cached mod files will have arbitrary file names to discourage attempts at replicating the original mod.");
-
-        public readonly string Paragraph4 = Loc.Localize("Paragraph4",
-            "The plugin creator tried their best to keep you secure. However, there is no guarantee for 100% security. Do not blindly pair your client with everyone.");
-
-        public readonly string Paragraph5 = Loc.Localize("Paragraph5",
-            "Mod files that are saved on the service will remain on the service as long as there are requests for the files from clients. " +
-            "After a period of not being used, the mod files will be automatically deleted. " +
-            "You will also be able to wipe all the files you have personally uploaded on request. " +
-            "The service holds no information about which mod files belong to which mod.");
-
-        public readonly string Paragraph6 = Loc.Localize("Paragraph6",
-            "This service is provided as-is. In case of abuse join the Lightless Sync Discord.");
-
-        public readonly string ReadLabel = Loc.Localize("ReadLabel", "READ THIS CAREFULLY");
-    }
-}

LightlessSync/Localization/de.json

@@ -1,46 +0,0 @@
-{
-  "LanguageLabel": {
-    "message": "Language",
-    "description": "ToSStrings..ctor"
-  },
-  "AgreementLabel": {
-    "message": "Nutzungsbedingungen",
-    "description": "ToSStrings..ctor"
-  },
-  "ReadLabel": {
-    "message": "BITTE LIES DIES SORGFÄLTIG",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph1": {
-    "message": "Alle Moddateien, die aktuell auf deinem Charakter aktiv sind und dein Charakterzustand werden automatisch zu dem Service, an dem du dich registriert hast, hochgeladen. Das Plugin wird ausschließlich die nötigen Moddateien hochladen und nicht die gesamte Modifikation.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph2": {
-    "message": "Falls du mit einer getakteten Internetverbindung verbunden bist, können durch den Datentransfer von Hoch- und Runtergeladenen Moddateien höhere Kosten entstehen. Moddateien werden beim Hoch- und Runterladen komprimiert um Bandbreite zu sparen. Durch unterschiedliche Hoch- und Runterladgeschwindigkeiten ist es möglich, dass Änderungen an Charakteren nicht sofort sichtbar sind. Dateien die bereits auf dem Service existieren, werden nicht nochmals hochgeladen.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph3": {
-    "message": "Die Moddateien die du hochlädst sind vertraulich und werden nicht mit anderen Nutzern geteilt, die nicht die exakt selben Dateien anfordern. Bitte überlege dir sorgfältig mit wem du deinen Identifikationscode teilst, da es unvermeidlich ist, dass die andere Person deine Moddateien erhält und lokal zwischenspeichert. Lokal zwischengespeicherte Dateien haben willkürrliche Namen um vor Versuchen abzuschrecken die originalen Moddateien aus diesen wiederherzustellen.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph4": {
-    "message": "Der Ersteller des Plugins hat sein Bestes getan, um deine Sicherheit zu gewährleisten. Es gibt jedoch keine Garantie für 100%ige Sicherheit. Teile deinen Identifikationscode nicht blind mit jedem.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph5": {
-    "message": "Moddateien, die auf dem Service gespeichert sind, verbleiben auf dem Service, solange es Anforderungen für diese Dateien gibt. Nach einer Zeitspanne in der die Dateien nicht verwendet wurden, werden diese automatisch gelöscht. Du hast auch die Möglichkeit manuell alle Dateien auf dem Service zu löschen. Der Service hat keine Informationen welche Moddateien zu welcher Modifikation gehören.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph6": {
-    "message": "Dieser Dienst wird ohne Gewähr angeboten. Im Falle eines Missbrauchs tretet dem Lightless Sync Discord bei.",
-    "description": "ToSStrings..ctor"
-  },
-  "AgreeLabel": {
-    "message": "Ich Stimme zu",
-    "description": "ToSStrings..ctor"
-  },
-  "ButtonWillBeAvailableIn": {
-    "message": "\"Ich stimme zu\" Knopf verfügbar in",
-    "description": "ToSStrings..ctor"
-  }
-}

LightlessSync/Localization/fr.json

@@ -1,46 +0,0 @@
-{
-  "LanguageLabel": {
-    "message": "Language",
-    "description": "ToSStrings..ctor"
-  },
-  "AgreementLabel": {
-    "message": "Conditions d'Utilisation",
-    "description": "ToSStrings..ctor"
-  },
-  "ReadLabel": {
-    "message": "LISEZ CES INFORMATIONS ATTENTIVEMENT",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph1": {
-    "message": "Tous les fichiers moddés actuellement en cours d'utilisation ainsi que le statut actuel de votre personnage vont être mix en ligne via le service sur lequel vous vous êtes automatiquement enregistré. Seuls les fichiers nécessaires seront téléversés par le plugin et non pas le mod en entier.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph2": {
-    "message": "Si le débit de votre connexion internet est limité, le téléchargement et téléversement d'un grand nombre de fichiers peut entraîner des coûts supplémentaires. Les fichiers seront compressés au chargement et versement pour réduire l'impact sur votre bande passants. Selon la rapidité de vos téléchargements et téléversements, les changements ne seront peut-être pas visibles instantanément sur les personnages. Les fichiers déja présents sur le service qui correspondent à ceux de vos mods en cours d'utilisation ne seront pas remis en ligne.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph3": {
-    "message": "Les fichiers que vous allez partager sont confidentiels et ne seront envoyés qu'aux utilisateurs qui feront une requête exacte de ceux-çi. Nous vous demandons de (re)considérer qui sera synchronisé avec vous, puisqu'ils recevront et stockeront inévitablement en local les fichiers nécéssaires utilisés à cet instant. Les noms des fichiers stockés localement sont changés de manière arbitraire afin de décourager toute tentative de réplication des originaux.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph4": {
-    "message": "Le créateur de ce plugin a tenté de sécuriser l'application du mieux possible. Cependant, il ne peut pas garantir une protection 100% infaillible. Pour votre sécurité, ne vous synchronisez pas aveuglément et avec n'importe qui.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph5": {
-    "message": "Les fichiers sauvegardés sur le service resteront en ligne tant que des utilisateurs en feront usage. Ils seront effacés automatiquement après une certaine période d'inactivité. Vous pouvez également demander l'effacement de tous les fichiers que vous avez mis en ligne vous-même. Le service en soi ne contient aucune information pouvant identifier quel fichier appartient à quel mod.",
-    "description": "ToSStrings..ctor"
-  },
-  "Paragraph6": {
-    "message": "Ce service et ses composants vous sont fournis en l'état. En cas d'abus rejoindre le serveur Discord Lightless Sync.",
-    "description": "ToSStrings..ctor"
-  },
-  "AgreeLabel": {
-    "message": "J'accept",
-    "description": "ToSStrings..ctor"
-  },
-  "ButtonWillBeAvailableIn": {
-    "message": "Bouton \"J'accept\" disposible dans",
-    "description": "ToSStrings..ctor"
-  }
-}

LightlessSync/MareConfiguration/Configurations/MareConfig.cs

@@ -1,63 +0,0 @@
-using LightlessSync.LightlessConfiguration.Models;
-using LightlessSync.UI;
-using Microsoft.Extensions.Logging;
-
-namespace LightlessSync.LightlessConfiguration.Configurations;
-
-[Serializable]
-public class LightlessConfig : ILightlessConfiguration
-{
-    public bool AcceptedAgreement { get; set; } = false;
-    public string CacheFolder { get; set; } = string.Empty;
-    public bool DisableOptionalPluginWarnings { get; set; } = false;
-    public bool EnableDtrEntry { get; set; } = false;
-    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 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 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;
-    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; } = true;
-    public bool ShowSyncshellUsersInVisible { get; set; } = true;
-    public bool ShowCharacterNameInsteadOfNotesForVisible { get; set; } = false;
-    public bool ShowOfflineUsersSeparately { get; set; } = true;
-    public bool ShowSyncshellOfflineUsersSeparately { get; set; } = true;
-    public bool GroupUpSyncshells { get; set; } = true;
-    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 bool DebugStopWhining { get; set; } = false;
-    public bool AutoPopulateEmptyNotesFromCharaName { get; set; } = false;
-    public int Version { get; set; } = 1;
-    public NotificationLocation WarningNotification { get; set; } = NotificationLocation.Both;
-    public bool UseFocusTarget { get; set; } = false;
-}

LightlessSync/MareConfiguration/Configurations/PlayerPerformanceConfig.cs

@@ -1,16 +0,0 @@
-namespace LightlessSync.LightlessConfiguration.Configurations;
-
-public class PlayerPerformanceConfig : ILightlessConfiguration
-{
-    public int Version { get; set; } = 1;
-    public bool ShowPerformanceIndicator { get; set; } = true;
-    public bool WarnOnExceedingThresholds { get; set; } = true;
-    public bool WarnOnPreferredPermissionsExceedingThresholds { get; set; } = false;
-    public int VRAMSizeWarningThresholdMiB { get; set; } = 375;
-    public int TrisWarningThresholdThousands { get; set; } = 165;
-    public bool AutoPausePlayersExceedingThresholds { get; set; } = false;
-    public bool AutoPausePlayersWithPreferredPermissionsExceedingThresholds { get; set; } = false;
-    public int VRAMSizeAutoPauseThresholdMiB { get; set; } = 550;
-    public int TrisAutoPauseThresholdThousands { get; set; } = 250;
-    public List<string> UIDsToIgnore { get; set; } = new();
-}

LightlessSync/MareConfiguration/Configurations/TransientConfig.cs

@@ -1,85 +0,0 @@
-using LightlessSync.API.Data.Enum;
-using LightlessSync.LightlessConfiguration.Configurations;
-
-namespace LightlessSync.LightlessConfiguration.Configurations;
-
-public class TransientConfig : ILightlessConfiguration
-{
-    public Dictionary<string, TransientPlayerConfig> TransientConfigs { get; set; } = [];
-    public int Version { get; set; } = 1;
-
-    public class TransientPlayerConfig
-    {
-        public List<string> GlobalPersistentCache { get; set; } = [];
-        public Dictionary<uint, List<string>> JobSpecificCache { get; set; } = [];
-        public Dictionary<uint, List<string>> JobSpecificPetCache { get; set; } = [];
-
-        public TransientPlayerConfig()
-        {
-
-        }
-
-        private bool ElevateIfNeeded(uint jobId, string gamePath)
-        {
-            // check if it's in the job cache of other jobs and elevate if needed
-            foreach (var kvp in JobSpecificCache)
-            {
-                if (kvp.Key == jobId) continue;
-
-                // elevate if the gamepath is included somewhere else
-                if (kvp.Value.Contains(gamePath, StringComparer.Ordinal))
-                {
-                    JobSpecificCache[kvp.Key].Remove(gamePath);
-                    GlobalPersistentCache.Add(gamePath);
-                    return true;
-                }
-            }
-
-            return false;
-        }
-
-        public int RemovePath(string gamePath, ObjectKind objectKind)
-        {
-            int removedEntries = 0;
-            if (objectKind == ObjectKind.Player)
-            {
-                if (GlobalPersistentCache.Remove(gamePath)) removedEntries++;
-                foreach (var kvp in JobSpecificCache)
-                {
-                    if (kvp.Value.Remove(gamePath)) removedEntries++;
-                }
-            }
-            if (objectKind == ObjectKind.Pet)
-            {
-                foreach (var kvp in JobSpecificPetCache)
-                {
-                    if (kvp.Value.Remove(gamePath)) removedEntries++;
-                }
-            }
-            return removedEntries;
-        }
-
-        public void AddOrElevate(uint jobId, string gamePath)
-        {
-            // check if it's in the global cache, if yes, do nothing
-            if (GlobalPersistentCache.Contains(gamePath, StringComparer.Ordinal))
-            {
-                return;
-            }
-
-            if (ElevateIfNeeded(jobId, gamePath)) return;
-
-            // check if the jobid is already in the cache to start
-            if (!JobSpecificCache.TryGetValue(jobId, out var jobCache))
-            {
-                JobSpecificCache[jobId] = jobCache = new();
-            }
-
-            // check if the path is already in the job specific cache
-            if (!jobCache.Contains(gamePath, StringComparer.Ordinal))
-            {
-                jobCache.Add(gamePath);
-            }
-        }
-    }
-}

LightlessSync/MareConfiguration/Models/NotificationLocation.cs

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

LightlessSync/MareConfiguration/Models/Obsolete/ServerStorageV0.cs

@@ -1,29 +0,0 @@
-namespace LightlessSync.LightlessConfiguration.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)
-        };
-    }
-}