Merge pull request 'Updated links for Xivapi sources' (#54 ) from xivapi-link-changes into master

Reviewed-on: #54
Updated links for Xivapi sources
2026-01-05 12:03:09 +00:00 · 2026-01-05 12:01:53 +00:00 · 2026-01-04 05:14:37 +00:00 · 2026-01-04 05:14:22 +00:00 · 2026-01-04 05:12:00 +00:00 · 2025-12-31 17:32:00 +00:00
55 changed files with 6794 additions and 418 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -351,3 +351,6 @@ MigrationBackup/

 # docker run data
 Docker/run/data/
+
+#idea files
+*.idea
--- a/2
+++ b/2
--- a/LightlessSyncServer/LightlessSyncAuthService/LightlessSyncAuthService.csproj
+++ b/LightlessSyncServer/LightlessSyncAuthService/LightlessSyncAuthService.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>
--- a/LightlessSyncServer/LightlessSyncAuthService/Services/GeoIPService.cs
+++ b/LightlessSyncServer/LightlessSyncAuthService/Services/GeoIPService.cs
@@ -44,12 +44,14 @@ public class GeoIPService : IHostedService
            if (_dbReader!.TryCity(ip, out var response))
            {
                string? continent = response?.Continent.Code;
+                string? countryIso = response?.Country.IsoCode;

                if (!string.IsNullOrEmpty(continent) &&
                    string.Equals(continent, "NA", StringComparison.Ordinal)
                    && response?.Location.Longitude != null)
                {
-                    if (response.Location.Longitude < -102)
+                    if (response.Location.Longitude < -102 &&
+                        !string.Equals(countryIso, "CA", StringComparison.OrdinalIgnoreCase))
                    {
                        continent = "NA-W";
                    }
@@ -57,6 +59,8 @@ public class GeoIPService : IHostedService
                    {
                        continent = "NA-E";
                    }
+
+                    _logger.LogDebug("Connecting {countryIso} to {continent}", countryIso, continent);
                }

                return continent ?? "*";
--- a/LightlessSyncServer/LightlessSyncServer/Configuration/ChatZoneOverridesOptions.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Configuration/ChatZoneOverridesOptions.cs
@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace LightlessSyncServer.Configuration;
+
+public sealed class ChatZoneOverridesOptions
+{
+    public List<ChatZoneOverride>? Zones { get; set; }
+}
+
+public sealed class ChatZoneOverride
+{
+    public string Key { get; set; } = string.Empty;
+    public string? DisplayName { get; set; }
+    public List<string>? TerritoryNames { get; set; }
+    public List<ushort>? TerritoryIds { get; set; }
+}
--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Chat.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Chat.cs
@@ -1,11 +1,7 @@
-using System;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
 using System.Text.Json;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Dto.Chat;
-using LightlessSync.API.Dto.User;
 using LightlessSyncServer.Models;
 using LightlessSyncServer.Services;
 using LightlessSyncServer.Utils;
@@ -13,12 +9,11 @@ using LightlessSyncShared.Models;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
-
 namespace LightlessSyncServer.Hubs;

 public partial class LightlessHub
 {
-    private const int MaxChatMessageLength = 400;
+    private const int MaxChatMessageLength = 200;
    private const int ChatRateLimitMessages = 7;
    private static readonly TimeSpan ChatRateLimitWindow = TimeSpan.FromMinutes(1);
    private static readonly ConcurrentDictionary<string, ChatRateLimitState> ChatRateLimiters = new(StringComparer.Ordinal);
@@ -46,8 +41,10 @@ public partial class LightlessHub

        var groupInfos = await DbContext.Groups
            .AsNoTracking()
-            .Where(g => g.OwnerUID == userUid
+            .Where(g => g.ChatEnabled
+                        && (g.OwnerUID == userUid
                        || DbContext.GroupPairs.Any(p => p.GroupGID == g.GID && p.GroupUserUID == userUid))
+                        )
            .ToListAsync()
            .ConfigureAwait(false);

@@ -67,7 +64,7 @@ public partial class LightlessHub
                    descriptor,
                    displayName,
                    g.GID,
-                    g.OwnerUID == userUid);
+                    string.Equals(g.OwnerUID, userUid, StringComparison.Ordinal));
            })
            .OrderBy(info => info.DisplayName, StringComparer.OrdinalIgnoreCase)
            .ToList();
@@ -85,14 +82,18 @@ public partial class LightlessHub

        if (userRecord.ChatBanned)
        {
-            _chatChannelService.RemovePresence(UserUID);
+            TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID), "clearing presence for banned user");
            await NotifyChatBanAsync(UserUID).ConfigureAwait(false);
            return;
        }

        if (!presence.IsActive)
        {
-            _chatChannelService.RemovePresence(UserUID, channel);
+            if (!TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID, channel), "removing chat presence", channel))
+            {
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "We couldn't update your chat presence. Please try again.").ConfigureAwait(false);
+            }
+
            return;
        }

@@ -126,14 +127,22 @@ public partial class LightlessHub
                    }
                }

-                _chatChannelService.UpdateZonePresence(
+                if (!TryInvokeChatService(
+                        () => _chatChannelService.UpdateZonePresence(
                            UserUID,
                            definition,
                            channel.WorldId,
                            presence.TerritoryId,
                            hashedCid,
                            isLightfinder,
-                    isActive: true);
+                            isActive: true),
+                        "updating zone chat presence",
+                        channel))
+                {
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Zone chat is temporarily unavailable. Please try again.").ConfigureAwait(false);
+                    return;
+                }
+
                break;

            case ChatChannelType.Group:
@@ -155,6 +164,13 @@ public partial class LightlessHub
                    throw new HubException("Unsupported chat channel.");
                }

+                if (!group.ChatEnabled)
+                {
+                    TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID, channel), "removing chat presence", channel);
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "This Syncshell chat is disabled.").ConfigureAwait(false);
+                    return;
+                }
+
                var isMember = string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal)
                    || await DbContext.GroupPairs
                        .AsNoTracking()
@@ -168,13 +184,21 @@ public partial class LightlessHub

                var displayName = string.IsNullOrWhiteSpace(group.Alias) ? group.GID : group.Alias;

-                _chatChannelService.UpdateGroupPresence(
+                if (!TryInvokeChatService(
+                        () => _chatChannelService.UpdateGroupPresence(
                            UserUID,
                            group.GID,
                            displayName,
                            userData,
                            IsValidHashedCid(UserCharaIdent) ? UserCharaIdent : null,
-                    isActive: true);
+                            isActive: true),
+                        "updating group chat presence",
+                        channel))
+                {
+                    await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Syncshell chat is temporarily unavailable. Please try again.").ConfigureAwait(false);
+                    return;
+                }
+
                break;

            default:
@@ -192,6 +216,23 @@ public partial class LightlessHub

        var channel = request.Channel.WithNormalizedCustomKey();

+        if (channel.Type == ChatChannelType.Group)
+        {
+            var groupId = channel.CustomKey ?? string.Empty;
+            var chatEnabled = !string.IsNullOrEmpty(groupId) && await DbContext.Groups
+                .AsNoTracking()
+                .Where(g => g.GID == groupId)
+                .Select(g => g.ChatEnabled)
+                .SingleOrDefaultAsync(RequestAbortedToken)
+                .ConfigureAwait(false);
+
+            if (!chatEnabled)
+            {
+                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "This Syncshell chat is disabled.").ConfigureAwait(false);
+                return;
+            }
+        }
+
        if (await HandleIfChatBannedAsync(UserUID).ConfigureAwait(false))
        {
            throw new HubException("Chat access has been revoked.");
@@ -214,6 +255,15 @@ public partial class LightlessHub
            sanitizedMessage = sanitizedMessage[..MaxChatMessageLength];
        }

+        if (channel.Type == ChatChannelType.Zone &&
+            !ChatMessageFilter.TryValidate(sanitizedMessage, out var rejectionReason))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, rejectionReason).ConfigureAwait(false);
+            return;
+        }
+
+        try
+        {
            var recipients = _chatChannelService.GetMembers(presence.Channel);
            var recipientsList = recipients.ToList();
            if (recipientsList.Count == 0)
@@ -250,6 +300,11 @@ public partial class LightlessHub

                if (_userConnections.TryGetValue(uid, out var connectionId))
                {
+                    if (_chatChannelService.IsTokenMuted(uid, presence.Channel, presence.Participant.Token))
+                    {
+                        continue;
+                    }
+
                    var includeSensitive = await AllowsLightfinderDetailsAsync(presence.Channel, uid).ConfigureAwait(false);
                    if (deliveryTargets.TryGetValue(connectionId, out var existing))
                    {
@@ -290,43 +345,11 @@ public partial class LightlessHub

            await Task.WhenAll(sendTasks).ConfigureAwait(false);
        }
-
-    [Authorize(Policy = "Identified")]
-    public async Task<ChatParticipantResolveResultDto?> ResolveChatParticipant(ChatParticipantResolveRequestDto request)
+        catch (Exception ex)
        {
-        var channel = request.Channel.WithNormalizedCustomKey();
-
-        if (!_chatChannelService.TryGetPresence(UserUID, channel, out _))
-        {
-            throw new HubException("Join the chat channel before resolving participants.");
+            _logger.LogError(ex, "Failed to deliver chat message for {User} in {Channel}", UserUID, DescribeChannel(presence.Channel));
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Something went wrong while sending your message. Please try again.").ConfigureAwait(false);
        }
-
-        if (!_chatChannelService.TryResolveParticipant(channel, request.Token, out var participant))
-        {
-            return null;
-        }
-
-        var viewerAllowsDetails = await ViewerAllowsLightfinderDetailsAsync(channel).ConfigureAwait(false);
-        var includeSensitiveInfo = channel.Type == ChatChannelType.Group || viewerAllowsDetails;
-
-        var sender = BuildSenderDescriptor(channel, participant, includeSensitiveInfo);
-
-        if (!includeSensitiveInfo)
-        {
-            return new ChatParticipantResolveResultDto(channel, sender, null);
-        }
-
-        UserProfileDto? profile = null;
-        if (channel.Type == ChatChannelType.Group)
-        {
-            profile = await LoadChatParticipantProfileAsync(participant.UserUid).ConfigureAwait(false);
-        }
-        else if (participant.IsLightfinder && !string.IsNullOrEmpty(participant.HashedCid))
-        {
-            profile = await LoadChatParticipantProfileAsync(participant.UserUid).ConfigureAwait(false);
-        }
-
-        return new ChatParticipantResolveResultDto(channel, sender, profile);
    }

    [Authorize(Policy = "Identified")]
@@ -334,12 +357,6 @@ public partial class LightlessHub
    {
        var channel = request.Channel.WithNormalizedCustomKey();

-        if (!_chatChannelService.TryGetPresence(UserUID, channel, out _))
-        {
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Join the chat channel before reporting messages.").ConfigureAwait(false);
-            return;
-        }
-
        if (!_chatChannelService.TryGetMessage(request.MessageId, out var messageEntry))
        {
            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Unable to locate the reported message. It may have already expired.").ConfigureAwait(false);
@@ -406,7 +423,7 @@ public partial class LightlessHub
            return;
        }

-        if (!string.IsNullOrEmpty(messageEntry.SenderUserUid))
+        /* if (!string.IsNullOrEmpty(messageEntry.SenderUserUid))
        {
            var targetAlreadyPending = await DbContext.ReportedChatMessages
                .AsNoTracking()
@@ -418,7 +435,7 @@ public partial class LightlessHub
                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "This user already has a report pending review.").ConfigureAwait(false);
                return;
            }
-        }
+        } */

        var snapshotEntries = _chatChannelService.GetRecentMessages(messageEntry.Channel, 25);
        var snapshotItems = snapshotEntries
@@ -446,7 +463,6 @@ public partial class LightlessHub
            MessageId = messageEntry.MessageId,
            MessageSentAtUtc = messageEntry.SentAtUtc,
            MessageContent = messageEntry.Message,
-            SenderToken = messageEntry.SenderToken,
            SenderHashedCid = messageEntry.SenderHashedCid,
            SenderDisplayName = messageEntry.SenderUser?.AliasOrUID,
            SenderWasLightfinder = messageEntry.SenderIsLightfinder,
@@ -461,6 +477,91 @@ public partial class LightlessHub
        await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "Thank you. Your report has been queued for moderator review.").ConfigureAwait(false);
    }

+    [Authorize(Policy = "Identified")]
+    public async Task SetChatParticipantMute(ChatParticipantMuteRequestDto request)
+    {
+        var channel = request.Channel.WithNormalizedCustomKey();
+
+        if (!_chatChannelService.TryGetPresence(UserUID, channel, out _))
+        {
+            throw new HubException("Join the chat channel before updating mutes.");
+        }
+
+        if (string.IsNullOrWhiteSpace(request.Token))
+        {
+            throw new HubException("Invalid participant.");
+        }
+
+        if (!_chatChannelService.TryGetActiveParticipant(channel, request.Token, out var participant))
+        {
+            throw new HubException("Unable to locate that participant in this channel.");
+        }
+
+        if (string.Equals(participant.UserUid, UserUID, StringComparison.Ordinal))
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, "You cannot mute yourself.").ConfigureAwait(false);
+            return;
+        }
+
+        ChatMuteUpdateResult result;
+        try
+        {
+            result = _chatChannelService.SetMutedParticipant(UserUID, channel, participant, request.Mute);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Failed to update mute for {User} in {Channel}", UserUID, DescribeChannel(channel));
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Unable to update mute settings right now. Please try again.").ConfigureAwait(false);
+            return;
+        }
+
+        if (result == ChatMuteUpdateResult.ChannelLimitReached)
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Warning, $"You can mute at most {ChatChannelService.MaxMutedParticipantsPerChannel} participants per channel. Unmute someone before adding another mute.").ConfigureAwait(false);
+            return;
+        }
+
+        if (result != ChatMuteUpdateResult.Changed)
+        {
+            return;
+        }
+
+        if (request.Mute)
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "You will no longer receive this participant's messages in the current channel.").ConfigureAwait(false);
+        }
+        else
+        {
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Information, "You will receive this participant's messages again.").ConfigureAwait(false);
+        }
+    }
+
+    private static string DescribeChannel(ChatChannelDescriptor descriptor) =>
+        $"{descriptor.Type}:{descriptor.WorldId}:{descriptor.CustomKey}";
+
+    private bool TryInvokeChatService(Action action, string operationDescription, ChatChannelDescriptor? descriptor = null, string? targetUserUid = null)
+    {
+        try
+        {
+            action();
+            return true;
+        }
+        catch (Exception ex)
+        {
+            var logUser = targetUserUid ?? UserUID;
+            if (descriptor is ChatChannelDescriptor described)
+            {
+                _logger.LogError(ex, "Chat service failed while {Operation} for {User} in {Channel}", operationDescription, logUser, DescribeChannel(described));
+            }
+            else
+            {
+                _logger.LogError(ex, "Chat service failed while {Operation} for {User}", operationDescription, logUser);
+            }
+
+            return false;
+        }
+    }
+
    private ChatSenderDescriptor BuildSenderDescriptor(ChatChannelDescriptor descriptor, ChatParticipantInfo participant, bool includeSensitiveInfo = false)
    {
        var kind = descriptor.Type == ChatChannelType.Group
@@ -487,7 +588,7 @@ public partial class LightlessHub
            ? participant.HashedCid
            : null;

-        var canResolveProfile = kind == ChatSenderKind.IdentifiedUser || participant.IsLightfinder;
+        var canResolveProfile = includeSensitiveInfo && (kind == ChatSenderKind.IdentifiedUser || participant.IsLightfinder);

        return new ChatSenderDescriptor(
            kind,
@@ -498,44 +599,6 @@ public partial class LightlessHub
            canResolveProfile);
    }

-    private async Task<UserProfileDto?> LoadChatParticipantProfileAsync(string userUid)
-    {
-        if (string.IsNullOrEmpty(userUid))
-            return null;
-
-        var targetUser = await DbContext.Users
-            .AsNoTracking()
-            .SingleOrDefaultAsync(u => u.UID == userUid, cancellationToken: RequestAbortedToken)
-            .ConfigureAwait(false);
-
-        if (targetUser is null)
-            return null;
-
-        var userData = targetUser.ToUserData();
-
-        var profileData = await DbContext.UserProfileData
-            .AsNoTracking()
-            .SingleOrDefaultAsync(p => p.UserUID == userUid, cancellationToken: RequestAbortedToken)
-            .ConfigureAwait(false);
-
-        if (profileData is null)
-        {
-            return new UserProfileDto(userData, Disabled: false, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: null, Tags: Array.Empty<int>());
-        }
-
-        if (profileData.FlaggedForReport)
-        {
-            return new UserProfileDto(userData, Disabled: true, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "This profile is flagged for report and pending evaluation", Tags: Array.Empty<int>());
-        }
-
-        if (profileData.ProfileDisabled)
-        {
-            return new UserProfileDto(userData, Disabled: true, IsNSFW: null, ProfilePictureBase64: null, BannerPictureBase64: null, Description: "This profile was permanently disabled", Tags: Array.Empty<int>());
-        }
-
-        return profileData.ToDTO();
-    }
-
    private async Task<bool> ViewerAllowsLightfinderDetailsAsync(ChatChannelDescriptor descriptor)
    {
        if (descriptor.Type == ChatChannelType.Group)
@@ -570,7 +633,11 @@ public partial class LightlessHub
            var (entry, expiry) = await TryGetBroadcastEntryAsync(presence.Participant.HashedCid!).ConfigureAwait(false);
            if (!IsActiveBroadcastForUser(entry, expiry, userUid))
            {
-                _chatChannelService.RefreshLightfinderState(userUid, null, isLightfinder: false);
+                TryInvokeChatService(
+                    () => _chatChannelService.RefreshLightfinderState(userUid, null, isLightfinder: false),
+                    "refreshing lightfinder state",
+                    descriptor,
+                    userUid);
                return false;
            }

@@ -590,7 +657,7 @@ public partial class LightlessHub
        if (!isBanned)
            return false;

-        _chatChannelService.RemovePresence(userUid);
+        TryInvokeChatService(() => _chatChannelService.RemovePresence(userUid), "clearing presence for chat-banned user", targetUserUid: userUid);
        await NotifyChatBanAsync(userUid).ConfigureAwait(false);
        return true;
    }
--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.ClientStubs.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.ClientStubs.cs
@@ -40,5 +40,6 @@ namespace LightlessSyncServer.Hubs
        public Task Client_GposeLobbyPushPoseData(UserData userData, PoseData poseData) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
        public Task Client_GposeLobbyPushWorldData(UserData userData, WorldData worldData) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
        public Task Client_ChatReceive(ChatMessageDto message) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
+        public Task Client_SendLocationToClient(LocationDto locationDto, DateTimeOffset expireAt) => throw new PlatformNotSupportedException("Calling clientside method on server not supported");
    }
 }
--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Functions.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Functions.cs
@@ -152,7 +152,7 @@ public partial class LightlessHub
        BroadcastRedisEntry? entry;
        try
        {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.ToString()!);
        }
        catch (Exception ex)
        {
--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.Groups.cs
@@ -1,6 +1,7 @@
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Data.Extensions;
+using LightlessSync.API.Dto.Chat;
 using LightlessSync.API.Dto.Group;
 using LightlessSync.API.Dto.User;
 using LightlessSyncServer.Models;
@@ -11,10 +12,8 @@ using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
-using Newtonsoft.Json.Linq;
 using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.PixelFormats;
-using System.Reflection;
+using System.Collections.Concurrent;
 using System.Security.Cryptography;

 namespace LightlessSyncServer.Hubs;
@@ -29,29 +28,78 @@ public partial class LightlessHub
        var (userHasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
        if (!userHasRights) return;

-        var (userExists, groupPair) = await TryValidateUserInGroup(dto.Group.GID, dto.User.UID).ConfigureAwait(false);
-        if (!userExists) return;
+        var targetUid = dto.User.UID?.Trim();
+        if (string.IsNullOrWhiteSpace(targetUid)) return;

-        if (groupPair.IsModerator || string.Equals(group.OwnerUID, dto.User.UID, StringComparison.Ordinal)) return;
+        if (string.Equals(group.OwnerUID, targetUid, StringComparison.Ordinal))
+            return;

-        var alias = string.IsNullOrEmpty(groupPair.GroupUser.Alias) ? "-" : groupPair.GroupUser.Alias;
-        var ban = new GroupBan()
+        var groupPair = await DbContext.GroupPairs
+            .Include(p => p.GroupUser)
+            .SingleOrDefaultAsync(p => p.GroupGID == dto.Group.GID && p.GroupUserUID == targetUid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+
+        if (groupPair?.IsModerator == true)
+            return;
+
+        var now = DateTime.UtcNow;
+
+        var existingBan = await DbContext.Set<GroupBan>().SingleOrDefaultAsync(b => b.GroupGID == dto.Group.GID && b.BannedUserUID == targetUid, cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+        var userExists = await DbContext.Users.AsNoTracking().AnyAsync(u => u.UID == targetUid || u.Alias == targetUid, RequestAbortedToken).ConfigureAwait(false);
+
+        if (!userExists && existingBan == null)
+            return;
+
+        const string marker = " (Alias at time of ban:";
+        string suffix;
+
+        if (existingBan?.BannedReason is { } existingReason)
+        {
+            var idx = existingReason.IndexOf(marker, StringComparison.Ordinal);
+            suffix = idx >= 0 ? existingReason.Substring(startIndex: idx) : string.Empty;
+        }
+        else
+        {
+            var alias = groupPair?.GroupUser?.Alias;
+            alias = string.IsNullOrWhiteSpace(alias) ? "-" : alias;
+            suffix = $" (Alias at time of ban: {alias})";
+        }
+
+        var baseReason = (reason ?? string.Empty).Trim();
+        var finalReason = string.IsNullOrEmpty(suffix) ? baseReason : (baseReason + suffix);
+
+        if (existingBan != null)
+        {
+            existingBan.BannedByUID = UserUID;
+            existingBan.BannedReason = finalReason;
+
+            DbContext.Update(existingBan);
+        }
+        else
+        {
+            var ban = new GroupBan
            {
                BannedByUID = UserUID,
-            BannedReason = $"{reason} (Alias at time of ban: {alias})",
-            BannedOn = DateTime.UtcNow,
-            BannedUserUID = dto.User.UID,
+                BannedReason = finalReason,
+                BannedOn = now,
+                BannedUserUID = targetUid,
                GroupGID = dto.Group.GID,
            };

            DbContext.Add(ban);
-        await DbContext.SaveChangesAsync().ConfigureAwait(false);
+        }

+        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+
+        if (groupPair != null)
+        {
            await GroupRemoveUser(dto).ConfigureAwait(false);
+        }

        _logger.LogCallInfo(LightlessHubLogger.Args(dto, "Success"));
    }

+    private static readonly ConcurrentDictionary<string, DateTime> GroupChatToggleCooldowns = new(StringComparer.Ordinal);
+
    [Authorize(Policy = "Identified")]
    public async Task GroupChangeGroupPermissionState(GroupPermissionDto dto)
    {
@@ -60,15 +108,73 @@ public partial class LightlessHub
        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
        if (!hasRights) return;

-        group.InvitesEnabled = !dto.Permissions.HasFlag(GroupPermissions.DisableInvites);
-        group.PreferDisableSounds = dto.Permissions.HasFlag(GroupPermissions.PreferDisableSounds);
-        group.PreferDisableAnimations = dto.Permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
-        group.PreferDisableVFX = dto.Permissions.HasFlag(GroupPermissions.PreferDisableVFX);
+        var permissions = dto.Permissions;
+        var isOwner = string.Equals(group.OwnerUID, UserUID, StringComparison.Ordinal);
+        var chatEnabled = group.ChatEnabled;
+        var chatChanged = false;
+
+        if (!isOwner)
+        {
+            permissions.SetDisableChat(!group.ChatEnabled);
+        }
+        else
+        {
+            var requestedChatEnabled = !permissions.IsDisableChat();
+            if (requestedChatEnabled != group.ChatEnabled)
+            {
+                var now = DateTime.UtcNow;
+                if (GroupChatToggleCooldowns.TryGetValue(group.GID, out var lockedUntil) && lockedUntil > now)
+                {
+                    var remaining = lockedUntil - now;
+                    var minutes = Math.Max(1, (int)Math.Ceiling(remaining.TotalMinutes));
+                    await Clients.Caller.Client_ReceiveServerMessage(
+                        MessageSeverity.Warning,
+                        $"Syncshell chat can be toggled again in {minutes} minute{(minutes == 1 ? string.Empty : "s")}."
+                    ).ConfigureAwait(false);
+                    permissions.SetDisableChat(!group.ChatEnabled);
+                }
+                else
+                {
+                    chatEnabled = requestedChatEnabled;
+                    group.ChatEnabled = chatEnabled;
+                    GroupChatToggleCooldowns[group.GID] = now.AddMinutes(5);
+                    chatChanged = true;
+                }
+            }
+        }
+
+        group.InvitesEnabled = !permissions.HasFlag(GroupPermissions.DisableInvites);
+        group.PreferDisableSounds = permissions.HasFlag(GroupPermissions.PreferDisableSounds);
+        group.PreferDisableAnimations = permissions.HasFlag(GroupPermissions.PreferDisableAnimations);
+        group.PreferDisableVFX = permissions.HasFlag(GroupPermissions.PreferDisableVFX);

        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);

        var groupPairs = DbContext.GroupPairs.Where(p => p.GroupGID == dto.Group.GID).Select(p => p.GroupUserUID).ToList();
-        await Clients.Users(groupPairs).Client_GroupChangePermissions(new GroupPermissionDto(dto.Group, dto.Permissions)).ConfigureAwait(false);
+        await Clients.Users(groupPairs).Client_GroupChangePermissions(new GroupPermissionDto(dto.Group, permissions)).ConfigureAwait(false);
+
+        if (isOwner && chatChanged && !chatEnabled)
+        {
+            var groupDisplayName = string.IsNullOrWhiteSpace(group.Alias) ? group.GID : group.Alias;
+            var descriptor = new ChatChannelDescriptor
+            {
+                Type = ChatChannelType.Group,
+                WorldId = 0,
+                ZoneId = 0,
+                CustomKey = group.GID
+            };
+
+            foreach (var uid in groupPairs)
+            {
+                TryInvokeChatService(() => _chatChannelService.RemovePresence(uid, descriptor), "removing group chat presence", descriptor, uid);
+            }
+
+            await Clients.Users(groupPairs)
+                .Client_ReceiveServerMessage(
+                    MessageSeverity.Information,
+                    $"Syncshell chat for '{groupDisplayName}' has been disabled.")
+                .ConfigureAwait(false);
+        }
    }

    [Authorize(Policy = "Identified")]
@@ -235,6 +341,7 @@ public partial class LightlessHub
            PreferDisableAnimations = defaultPermissions.DisableGroupAnimations,
            PreferDisableSounds = defaultPermissions.DisableGroupSounds,
            PreferDisableVFX = defaultPermissions.DisableGroupVFX,
+            ChatEnabled = true,
            CreatedDate = currentTime,
        };

@@ -264,7 +371,7 @@ public partial class LightlessHub
        var self = await DbContext.Users.SingleAsync(u => u.UID == UserUID, cancellationToken: RequestAbortedToken).ConfigureAwait(false);

        await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(newGroup.ToGroupData(), self.ToUserData(),
-            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal)))
+            newGroup.ToEnum(), initialPrefPermissions.ToEnum(), initialPair.ToEnum(), new(StringComparer.Ordinal), 1))
            .ConfigureAwait(false);

        _logger.LogCallInfo(LightlessHubLogger.Args(gid));
@@ -340,9 +447,9 @@ public partial class LightlessHub

        var banEntries = await DbContext.GroupBans.Include(b => b.BannedUser).Where(g => g.GroupGID == dto.Group.GID).AsNoTracking().ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);

-        List<BannedGroupUserDto> bannedGroupUsers = banEntries.Select(b =>
+        List<BannedGroupUserDto> bannedGroupUsers = [.. banEntries.Select(b =>
            new BannedGroupUserDto(group.ToGroupData(), b.BannedUser.ToUserData(), b.BannedReason, b.BannedOn,
-                b.BannedByUID)).ToList();
+                b.BannedByUID))];

        _logger.LogCallInfo(LightlessHubLogger.Args(dto, bannedGroupUsers.Count));

@@ -454,9 +561,14 @@ public partial class LightlessHub
        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);

        var groupInfos = await DbContext.GroupPairs.Where(u => u.GroupGID == group.GID && (u.IsPinned || u.IsModerator)).ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+        var totalUserCount = await DbContext.GroupPairs
+            .AsNoTracking()
+            .CountAsync(u => u.GroupGID == group.GID, RequestAbortedToken)
+            .ConfigureAwait(false);
+
        await Clients.User(UserUID).Client_GroupSendFullInfo(new GroupFullInfoDto(group.ToGroupData(), group.Owner.ToUserData(),
            group.ToEnum(), preferredPermissions.ToEnum(), newPair.ToEnum(),
-            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal))).ConfigureAwait(false);
+            groupInfos.ToDictionary(u => u.GroupUserUID, u => u.ToEnum(), StringComparer.Ordinal), totalUserCount)).ConfigureAwait(false);

        var self = DbContext.Users.Single(u => u.UID == UserUID);

@@ -678,30 +790,38 @@ public partial class LightlessHub
    {
        _logger.LogCallInfo(LightlessHubLogger.Args(dto, days, execute));

-        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID).ConfigureAwait(false);
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
+            .ConfigureAwait(false);
        if (!hasRights) return -1;

-        var allGroupUsers = await DbContext.GroupPairs.Include(p => p.GroupUser).Include(p => p.Group)
-            .Where(g => g.GroupGID == dto.Group.GID)
-            .ToListAsync().ConfigureAwait(false);
-        var usersToPrune = allGroupUsers.Where(p => !p.IsPinned && !p.IsModerator
-            && !string.Equals(p.GroupUserUID, UserUID, StringComparison.Ordinal)
-            && !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal)
-            && p.GroupUser.LastLoggedIn.AddDays(days) < DateTime.UtcNow);
-
-        if (!execute) return usersToPrune.Count();
-
-        DbContext.GroupPairs.RemoveRange(usersToPrune);
-
-        foreach (var pair in usersToPrune)
+        if (!execute)
        {
-            await Clients.Users(allGroupUsers.Where(p => !usersToPrune.Contains(p)).Select(g => g.GroupUserUID))
-                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData())).ConfigureAwait(false);
+            var count = await _pruneService.CountPrunableUsersAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
+            return count;
        }

-        await DbContext.SaveChangesAsync(RequestAbortedToken).ConfigureAwait(false);
+        var allGroupUsers = await DbContext.GroupPairs
+            .Include(p => p.GroupUser)
+            .Include(p => p.Group)
+            .Where(g => g.GroupGID == dto.Group.GID)
+            .ToListAsync(RequestAbortedToken).ConfigureAwait(false);

-        return usersToPrune.Count();
+        var prunedPairs = await _pruneService.ExecutePruneAsync(dto.Group.GID, days, RequestAbortedToken).ConfigureAwait(false);
+
+        var remainingUserIds = allGroupUsers
+            .Where(p => !prunedPairs.Any(x => string.Equals(x.GroupUserUID, p.GroupUserUID, StringComparison.Ordinal)))
+            .Select(p => p.GroupUserUID)
+            .Distinct(StringComparer.Ordinal)
+            .ToList();
+
+        foreach (var pair in prunedPairs)
+        {
+            await Clients.Users(remainingUserIds)
+                .Client_GroupPairLeft(new GroupPairDto(dto.Group, pair.GroupUser.ToUserData()))
+                .ConfigureAwait(false);
+        }
+
+        return prunedPairs.Count;
    }

    [Authorize(Policy = "Identified")]
@@ -839,8 +959,9 @@ public partial class LightlessHub
            {
                GroupGID = dto.Group.GID,
                Group = group,
-                ProfileDisabled = false,
+                ProfileDisabled = dto.IsDisabled ?? false,
                IsNSFW = dto.IsNsfw ?? false,
+
            };

            groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
@@ -850,12 +971,6 @@ public partial class LightlessHub
        {
            groupProfileDb.Group ??= group;

-            if (groupProfileDb?.ProfileDisabled ?? false)
-            {
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile was permanently disabled and cannot be edited").ConfigureAwait(false);
-                return;
-            }
-
            groupProfileDb.UpdateProfileFromDto(dto, sanitizedProfileImage, sanitizedBannerImage);
        }

@@ -910,6 +1025,44 @@ public partial class LightlessHub
        await Clients.Users(groupPairs).Client_GroupPairChangeUserInfo(new GroupPairUserInfoDto(dto.Group, dto.User, userPair.ToEnum())).ConfigureAwait(false);
    }

+    [Authorize(Policy = "Identified")]
+    public async Task<GroupPruneSettingsDto> GroupGetPruneSettings(GroupDto dto)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
+
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.GID)
+            .ConfigureAwait(false);
+        if (!hasRights || group == null)
+            return null;
+
+        return new GroupPruneSettingsDto(
+            Group: group.ToGroupData(),
+            AutoPruneEnabled: group.AutoPruneEnabled,
+            AutoPruneDays: group.AutoPruneDays
+        );
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task GroupSetPruneSettings(GroupPruneSettingsDto dto)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(dto));
+
+        var (hasRights, group) = await TryValidateGroupModeratorOrOwner(dto.Group.GID)
+            .ConfigureAwait(false);
+        if (!hasRights || group == null)
+            return;
+
+        // if days == 0, auto prune is OFF
+        var days = dto.AutoPruneDays;
+        var enabled = dto.AutoPruneEnabled && days > 0;
+
+        group.AutoPruneEnabled = enabled;
+        group.AutoPruneDays = enabled ? days : 0;
+
+        await DbContext.SaveChangesAsync(RequestAbortedToken)
+            .ConfigureAwait(false);
+    }
+
    [Authorize(Policy = "Identified")]
    public async Task<List<GroupFullInfoDto>> GroupsGetAll()
    {
@@ -932,6 +1085,8 @@ public partial class LightlessHub
                    .Where(x => x.GroupGID == gp.GroupGID && (x.IsPinned || x.IsModerator))
                    .Select(x => new { x.GroupUserUID, EnumValue = x.ToEnum() })
                    .ToList(),
+                UserCount = DbContext.GroupPairs
+                    .Count(x => x.GroupGID == gp.GroupGID),
            })
            .AsNoTracking()
            .ToListAsync()
@@ -944,7 +1099,6 @@ public partial class LightlessHub
        var groupInfoDict = r.GroupInfos
            .ToDictionary(x => x.GroupUserUID, x => x.EnumValue, StringComparer.Ordinal);

-
        _logger.LogCallInfo(LightlessHubLogger.Args(r));

        return new GroupFullInfoDto(
@@ -953,7 +1107,8 @@ public partial class LightlessHub
            r.GroupPair.Group.ToEnum(),
            r.PreferredPermission.ToEnum(),
            r.GroupPair.ToEnum(),
-                groupInfoDict
+            groupInfoDict,
+            r.UserCount
        );
        }),];
        return List;
@@ -995,11 +1150,11 @@ public partial class LightlessHub
            return false;
        }

-        var (isOwner, _) = await TryValidateOwner(dto.GID).ConfigureAwait(false);
-        if (!isOwner)
+        var (isOwnerOrMod, _) = await TryValidateGroupModeratorOrOwner(dto.GID).ConfigureAwait(false);
+        if (!isOwnerOrMod)
        {
            _logger.LogCallWarning(LightlessHubLogger.Args("Unauthorized syncshell broadcast change", "User", UserUID, "GID", dto.GID));
-            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You must be the owner of the syncshell to broadcast it.");
+            await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "You must be the owner or moderator of the syncshell to broadcast it.");
            return false;
        }

--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.User.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.User.cs
@@ -12,8 +12,6 @@ using LightlessSyncShared.Utils;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
-using SixLabors.ImageSharp;
-using SixLabors.ImageSharp.PixelFormats;
 using StackExchange.Redis;
 using System.Text;
 using System.Text.Json;
@@ -336,7 +334,7 @@ public partial class LightlessHub
        BroadcastRedisEntry? entry;
        try
        {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.Value!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(broadcastValue.Value.ToString()!);
        }
        catch (Exception ex)
        {
@@ -438,7 +436,7 @@ public partial class LightlessHub
            {
                try
                {
-                    existingEntry = JsonSerializer.Deserialize<BroadcastRedisEntry>(existingValue!);
+                    existingEntry = JsonSerializer.Deserialize<BroadcastRedisEntry>(existingValue.ToString()!);
                }
                catch (Exception ex)
                {
@@ -464,7 +462,9 @@ public partial class LightlessHub
            await db.StringSetAsync(broadcastKey, json, _broadcastConfiguration.BroadcastEntryTtl).ConfigureAwait(false);
            await db.StringSetAsync(ownershipKey, hashedCid, _broadcastConfiguration.BroadcastEntryTtl).ConfigureAwait(false);
            _logger.LogCallInfo(LightlessHubLogger.Args("broadcast enabled", hashedCid, "GID", gid));
-            _chatChannelService.RefreshLightfinderState(UserUID, hashedCid, isLightfinder: true);
+            TryInvokeChatService(
+                () => _chatChannelService.RefreshLightfinderState(UserUID, hashedCid, isLightfinder: true),
+                "refreshing lightfinder state (enable)");
        }
        else
        {
@@ -475,7 +475,7 @@ public partial class LightlessHub
            BroadcastRedisEntry? entry;
            try
            {
-                entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value!);
+                entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.ToString()!);
            }
            catch (Exception ex)
            {
@@ -505,7 +505,9 @@ public partial class LightlessHub
            }

            _logger.LogCallInfo(LightlessHubLogger.Args("broadcast disabled", hashedCid, "GID", entry.GID));
-            _chatChannelService.RefreshLightfinderState(UserUID, null, isLightfinder: false);
+            TryInvokeChatService(
+                () => _chatChannelService.RefreshLightfinderState(UserUID, null, isLightfinder: false),
+                "refreshing lightfinder state (disable)");
        }
    }

@@ -532,7 +534,7 @@ public partial class LightlessHub
        BroadcastRedisEntry? entry;
        try
        {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.Value!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.Value.ToString()!);
        }
        catch (Exception ex)
        {
@@ -586,7 +588,7 @@ public partial class LightlessHub
        BroadcastRedisEntry? entry;
        try
        {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(result.Value!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(result.Value.ToString()!);
        }
        catch
        {
@@ -641,7 +643,7 @@ public partial class LightlessHub
        BroadcastRedisEntry? entry;
        try
        {
-            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value!);
+            entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(value.ToString()!);
        }
        catch
        {
@@ -724,7 +726,7 @@ public partial class LightlessHub

                try
                {
-                    entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(raw!);
+                    entry = JsonSerializer.Deserialize<BroadcastRedisEntry>(raw.ToString()!);
                    if (entry is not null && !string.Equals(entry.HashedCID, cid, StringComparison.Ordinal))
                    {
                        _logger.LogCallWarning(LightlessHubLogger.Args("mismatched broadcast cid in batch", "Requested", cid, "EntryCID", entry.HashedCID));
@@ -1167,12 +1169,6 @@ public partial class LightlessHub
                return;
            }

-            if (profileData.ProfileDisabled)
-            {
-                await Clients.Caller.Client_ReceiveServerMessage(MessageSeverity.Error, "Your profile was permanently disabled and cannot be edited").ConfigureAwait(false);
-                return;
-            }
-
            profileData.UpdateProfileFromDto(dto, profileResult.Base64Image, bannerResult.Base64Image);
        }
        else
@@ -1235,6 +1231,120 @@ public partial class LightlessHub
        return true;
    }
    
+    [Authorize(Policy = "Identified")]
+    public async Task UpdateLocation(LocationDto dto, bool offline = false)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(UserUID,dto));
+        if (string.IsNullOrEmpty(dto.User.UID))
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LocationDto with no userinfo :",UserUID, dto));
+            return;
+        }
+
+        if (!string.Equals(UserUID, dto.User.UID, StringComparison.Ordinal))
+        {
+            _logger.LogCallWarning(LightlessHubLogger.Args("LocationDto with another UID :",UserUID, dto));
+            return;
+        }
+        var key = $"Location:{UserUID}";
+        
+        if (offline)
+        {
+            var allUsers = await GetSharingUsers().ConfigureAwait(false);   
+            await _redis.RemoveAsync(key, CommandFlags.FireAndForget).ConfigureAwait(false);
+            await Clients.Users(allUsers.Keys).Client_SendLocationToClient(dto, DateTimeOffset.MinValue).ConfigureAwait(false);
+        }
+        else
+        {
+            var currentLocation = await _redis.GetAsync<LocationDto>(key).ConfigureAwait(false);
+            if (currentLocation != dto)
+            {
+                var allUsers = await GetSharingUsers().ConfigureAwait(false);   
+                await _redis.AddAsync(key, dto).ConfigureAwait(false);
+                var sendTasks = allUsers.Select(pair => Clients.User(pair.Key).Client_SendLocationToClient(dto, pair.Value));
+                await Task.WhenAll(sendTasks).ConfigureAwait(false);
+            }
+        }
+    }
+    
+    private async Task<Dictionary<string, DateTimeOffset>> GetSharingUsers()
+    {
+        return await DbContext.Permissions.AsNoTracking()
+            .Where(x => x.UserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
+            .ToDictionaryAsync(x => x.OtherUserUID, x => x.ShareLocationUntil, RequestAbortedToken)
+            .ConfigureAwait(false);
+    }
+
+    [Authorize(Policy = "Identified")]
+    public async Task<(List<LocationWithTimeDto>, List<SharingStatusDto>)> RequestAllLocationInfo()
+    {
+        _logger.LogCallInfo();
+        var locationWithTime = await GetLocationWithTime().ConfigureAwait(false);
+        var sharingStatus = await GetSharingStatus().ConfigureAwait(false);
+        return (locationWithTime, sharingStatus);
+    }
+
+    private async Task<List<LocationWithTimeDto>> GetLocationWithTime()
+    {
+        var dictionary = await DbContext.Permissions.AsNoTracking()
+            .Where(x => x.OtherUserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
+            .ToDictionaryAsync(x => x.UserUID, x => x.ShareLocationUntil, cancellationToken: RequestAbortedToken)
+            .ConfigureAwait(false);
+        if (dictionary.Count == 0)
+        {
+            return [];
+        }
+
+        var redisKeys = dictionary.Keys.Select(uid => $"Location:{uid}").ToHashSet(StringComparer.Ordinal);
+        var data = await _redis.GetAllAsync<LocationDto>(redisKeys).ConfigureAwait(false);
+        var result = new List<LocationWithTimeDto>();
+
+        foreach (var (userUid, expireAt) in dictionary)
+        {
+            var redisKey = $"Location:{userUid}";
+
+            if (data.TryGetValue(redisKey, out var locationDto) && locationDto is not null)
+            {
+                result.Add(new LocationWithTimeDto(locationDto, expireAt));
+            }
+        }
+        return result;
+    }
+
+    private async Task<List<SharingStatusDto>> GetSharingStatus()
+    {
+        return await DbContext.Permissions.AsNoTracking()
+            .Where(x => x.UserUID == UserUID && x.ShareLocationUntil > DateTimeOffset.UtcNow)
+            .Select(x => new SharingStatusDto(new UserData(x.OtherUserUID), x.ShareLocationUntil))
+            .ToListAsync(cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+    }
+
+
+
+    [Authorize(Policy = "Identified")]
+    public async Task<bool> ToggleLocationSharing(LocationSharingToggleDto dto)
+    {
+        _logger.LogCallInfo(LightlessHubLogger.Args(UserUID,dto));
+        try
+        {
+            await DbContext.Permissions.Where(x => x.UserUID == UserUID && dto.users.Contains(x.OtherUserUID))
+                .ExecuteUpdateAsync(setter =>
+                        setter.SetProperty(x => x.ShareLocationUntil, dto.duration.ToUniversalTime()),
+                    cancellationToken: RequestAbortedToken).ConfigureAwait(false);
+
+            //update user's location for target users
+            var currentLocation = await _redis.GetAsync<LocationDto>($"Location:{UserUID}").ConfigureAwait(false);
+            await Clients.Users(dto.users).Client_SendLocationToClient(currentLocation, dto.duration.ToUniversalTime())
+                .ConfigureAwait(false);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "ToggleLocationSharing error:");
+            return false;
+        }
+        return true;
+    }
+
    [GeneratedRegex(@"^([a-z0-9_ '+&,\.\-\{\}]+\/)+([a-z0-9_ '+&,\.\-\{\}]+\.[a-z]{3,4})$", RegexOptions.IgnoreCase | RegexOptions.Compiled | RegexOptions.ECMAScript)]
    private static partial Regex GamePathRegex();

--- a/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Hubs/LightlessHub.cs
@@ -1,7 +1,6 @@
 using LightlessSync.API.Data;
 using LightlessSync.API.Data.Enum;
 using LightlessSync.API.Dto;
-using LightlessSync.API.Dto.Chat;
 using LightlessSync.API.SignalR;
 using LightlessSyncServer.Services;
 using LightlessSyncServer.Configuration;
@@ -17,8 +16,9 @@ using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
 using StackExchange.Redis.Extensions.Core.Abstractions;
 using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Linq;
+using LightlessSync.API.Dto.CharaData;
+using LightlessSync.API.Dto.User;
+using LightlessSyncServer.Services.Interfaces;

 namespace LightlessSyncServer.Hubs;

@@ -29,6 +29,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
    private readonly LightlessMetrics _lightlessMetrics;
    private readonly SystemInfoService _systemInfoService;
    private readonly PairService _pairService;
+    private readonly IPruneService _pruneService;
    private readonly IHttpContextAccessor _contextAccessor;
    private readonly LightlessHubLogger _logger;
    private readonly string _shardName;
@@ -55,7 +56,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
        IConfigurationService<ServerConfiguration> configuration, IHttpContextAccessor contextAccessor,
        IRedisDatabase redisDb, OnlineSyncedPairCacheService onlineSyncedPairCacheService, LightlessCensus lightlessCensus,
        GPoseLobbyDistributionService gPoseLobbyDistributionService, IBroadcastConfiguration broadcastConfiguration, PairService pairService,
-        ChatChannelService chatChannelService)
+        ChatChannelService chatChannelService, IPruneService pruneService)
    {
        _lightlessMetrics = lightlessMetrics;
        _systemInfoService = systemInfoService;
@@ -77,6 +78,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
        _broadcastConfiguration = broadcastConfiguration;
        _pairService = pairService;
        _chatChannelService = chatChannelService;
+        _pruneService = pruneService;
    }

    protected override void Dispose(bool disposing)
@@ -218,6 +220,8 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub

                _lightlessCensus.ClearStatistics(UserUID);
                
+                await UpdateLocation(new LocationDto(new UserData(UserUID), new LocationInfo()), offline: true).ConfigureAwait(false);
+
                await SendOfflineToAllPairedUsers().ConfigureAwait(false);

                DbContext.RemoveRange(DbContext.Files.Where(f => !f.Uploaded && f.UploaderUID == UserUID));
@@ -227,7 +231,7 @@ public partial class LightlessHub : Hub<ILightlessHub>, ILightlessHub
            catch { }
            finally
            {
-                _chatChannelService.RemovePresence(UserUID);
+                TryInvokeChatService(() => _chatChannelService.RemovePresence(UserUID), "removing chat presence on disconnect");
                _userConnections.Remove(UserUID, out _);
            }
        }
--- a/LightlessSyncServer/LightlessSyncServer/LightlessSyncServer.csproj
+++ b/LightlessSyncServer/LightlessSyncServer/LightlessSyncServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
    <UserSecretsId>aspnet-LightlessSyncServer-BA82A12A-0B30-463C-801D-B7E81318CD50</UserSecretsId>
    <AssemblyVersion>1.1.0.0</AssemblyVersion>
    <ImplicitUsings>enable</ImplicitUsings>
--- a/LightlessSyncServer/LightlessSyncServer/Models/ChatModels.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Models/ChatModels.cs
@@ -1,6 +1,4 @@
-using System;
-using System.Collections.Generic;
-using LightlessSync.API.Data;
+using LightlessSync.API.Data;
 using LightlessSync.API.Dto.Chat;

 namespace LightlessSyncServer.Models;
@@ -32,7 +30,6 @@ public readonly record struct ChatMessageLogEntry(
    string MessageId,
    ChatChannelDescriptor Channel,
    DateTime SentAtUtc,
-    string SenderToken,
    string SenderUserUid,
    UserData? SenderUser,
    bool SenderIsLightfinder,
--- a/LightlessSyncServer/LightlessSyncServer/Models/ChatZoneDefinitions.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Models/ChatZoneDefinitions.cs
@@ -1,5 +1,4 @@
-using System.Collections.Generic;
-using LightlessSync.API.Dto.Chat;
+using LightlessSync.API.Dto.Chat;

 namespace LightlessSyncServer.Models;

@@ -61,7 +60,6 @@ internal static class ChatZoneDefinitions
                },
                TerritoryIds: TerritoryRegistry.GetIds(
                    "Ul'dah - Steps of Nald",
-                    "Ul'dah - Steps of Thal"))
+                    "Ul'dah - Steps of Thal")),
        };
-
 }
--- a/LightlessSyncServer/LightlessSyncServer/Services/ChatChannelService.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Services/ChatChannelService.cs
@@ -1,15 +1,13 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Security.Cryptography;
+using System.Security.Cryptography;
 using LightlessSync.API.Data;
 using LightlessSync.API.Dto.Chat;
+using LightlessSyncServer.Configuration;
 using LightlessSyncServer.Models;
-using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;

 namespace LightlessSyncServer.Services;

-public sealed class ChatChannelService
+public sealed class ChatChannelService : IDisposable
 {
    private readonly ILogger<ChatChannelService> _logger;
    private readonly Dictionary<string, ZoneChannelDefinition> _zoneDefinitions;
@@ -18,16 +16,137 @@ public sealed class ChatChannelService
    private readonly Dictionary<ChannelKey, Dictionary<string, ChatParticipantInfo>> _participantsByChannel = new();
    private readonly Dictionary<ChannelKey, LinkedList<ChatMessageLogEntry>> _messagesByChannel = new();
    private readonly Dictionary<string, (ChannelKey Channel, LinkedListNode<ChatMessageLogEntry> Node)> _messageIndex = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, Dictionary<ChannelKey, HashSet<string>>> _mutedTokensByUser = new(StringComparer.Ordinal);
+    private readonly Dictionary<string, Dictionary<ChannelKey, HashSet<string>>> _mutedUidsByUser = new(StringComparer.Ordinal);
    private readonly object _syncRoot = new();
    private const int MaxMessagesPerChannel = 200;
+    internal const int MaxMutedParticipantsPerChannel = 8;

-    public ChatChannelService(ILogger<ChatChannelService> logger)
+    public ChatChannelService(ILogger<ChatChannelService> logger, IOptions<ChatZoneOverridesOptions>? zoneOverrides = null)
    {
        _logger = logger;
-        _zoneDefinitions = ChatZoneDefinitions.Defaults
-            .ToDictionary(definition => definition.Key, StringComparer.OrdinalIgnoreCase);
+        _zoneDefinitions = BuildZoneDefinitions(zoneOverrides?.Value);
    }

+    private Dictionary<string, ZoneChannelDefinition> BuildZoneDefinitions(ChatZoneOverridesOptions? overrides)
+    {
+        var definitions = ChatZoneDefinitions.Defaults
+            .ToDictionary(definition => definition.Key, StringComparer.OrdinalIgnoreCase);
+
+        if (overrides?.Zones is null || overrides.Zones.Count == 0)
+        {
+            return definitions;
+        }
+
+        foreach (var entry in overrides.Zones)
+        {
+            if (entry is null)
+            {
+                continue;
+            }
+
+            if (!TryCreateZoneDefinition(entry, out var definition))
+            {
+                continue;
+            }
+
+            definitions[definition.Key] = definition;
+        }
+
+        return definitions;
+    }
+
+    private bool TryCreateZoneDefinition(ChatZoneOverride entry, out ZoneChannelDefinition definition)
+    {
+        definition = default;
+
+        var key = NormalizeZoneKey(entry.Key);
+        if (string.IsNullOrEmpty(key))
+        {
+            _logger.LogWarning("Skipped chat zone override with missing key.");
+            return false;
+        }
+
+        var territoryIds = new HashSet<ushort>();
+        if (entry.TerritoryIds is not null)
+        {
+            foreach (var candidate in entry.TerritoryIds)
+            {
+                if (candidate > 0)
+                {
+                    territoryIds.Add(candidate);
+                }
+            }
+        }
+
+        var territoryNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        if (entry.TerritoryNames is not null)
+        {
+            foreach (var name in entry.TerritoryNames)
+            {
+                if (string.IsNullOrWhiteSpace(name))
+                    continue;
+
+                var trimmed = name.Trim();
+                territoryNames.Add(trimmed);
+                if (TerritoryRegistry.TryGetIds(trimmed, out var ids))
+                {
+                    territoryIds.UnionWith(ids);
+                }
+                else
+                {
+                    _logger.LogWarning("Chat zone override {Zone} references unknown territory '{Territory}'.", key, trimmed);
+                }
+            }
+        }
+
+        if (territoryIds.Count == 0)
+        {
+            _logger.LogWarning("Skipped chat zone override for {Zone}: no territory IDs resolved.", key);
+            return false;
+        }
+
+        if (territoryNames.Count == 0)
+        {
+            foreach (var territoryId in territoryIds)
+            {
+                if (TerritoryRegistry.ById.TryGetValue(territoryId, out var territory))
+                {
+                    territoryNames.Add(territory.Name);
+                }
+            }
+        }
+
+        if (territoryNames.Count == 0)
+        {
+            territoryNames.Add("Territory");
+        }
+
+        var descriptor = new ChatChannelDescriptor
+        {
+            Type = ChatChannelType.Zone,
+            WorldId = 0,
+            ZoneId = 0,
+            CustomKey = key
+        };
+
+        var displayName = string.IsNullOrWhiteSpace(entry.DisplayName)
+            ? key
+            : entry.DisplayName.Trim();
+
+        definition = new ZoneChannelDefinition(
+            key,
+            displayName,
+            descriptor,
+            territoryNames.ToArray(),
+            territoryIds);
+
+        return true;
+    }
+
+    private static string NormalizeZoneKey(string? value) =>
+        string.IsNullOrWhiteSpace(value) ? string.Empty : value.Trim();
+
    public IReadOnlyList<ZoneChatChannelInfoDto> GetZoneChannelInfos() =>
        _zoneDefinitions.Values
            .Select(definition => new ZoneChatChannelInfoDto(
@@ -154,7 +273,6 @@ public sealed class ChatChannelService
            messageId,
            channel,
            sentAtUtc,
-            participant.Token,
            participant.UserUid,
            participant.User,
            participant.IsLightfinder,
@@ -260,23 +378,6 @@ public sealed class ChatChannelService
        }
    }

-    public bool TryResolveParticipant(ChatChannelDescriptor channel, string token, out ChatParticipantInfo participant)
-    {
-        var key = ChannelKey.FromDescriptor(channel);
-
-        lock (_syncRoot)
-        {
-            if (_participantsByChannel.TryGetValue(key, out var participants) &&
-                participants.TryGetValue(token, out participant))
-            {
-                return true;
-            }
-        }
-
-        participant = default;
-        return false;
-    }
-
    public void RefreshLightfinderState(string userUid, string? hashedCid, bool isLightfinder)
    {
        ArgumentException.ThrowIfNullOrEmpty(userUid);
@@ -413,6 +514,8 @@ public sealed class ChatChannelService

            participantsByToken[token] = finalParticipant;

+            ApplyUIDMuteIfPresent(normalizedDescriptor, finalParticipant);
+
            _logger.LogDebug("Chat presence updated for {User} in {Channel}", userUid, Describe(key));
            return entryToStore;
        }
@@ -446,9 +549,113 @@ public sealed class ChatChannelService
            }
        }

+        ClearMutesForChannel(userUid, key);
        return true;
    }

+    internal bool TryGetActiveParticipant(ChatChannelDescriptor channel, string token, out ChatParticipantInfo participant)
+    {
+        var key = ChannelKey.FromDescriptor(channel.WithNormalizedCustomKey());
+
+        lock (_syncRoot)
+        {
+            if (_participantsByChannel.TryGetValue(key, out var participants) &&
+                participants.TryGetValue(token, out participant))
+            {
+                return true;
+            }
+        }
+
+        participant = default;
+        return false;
+    }
+
+    internal bool IsTokenMuted(string userUid, ChatChannelDescriptor channel, string token)
+    {
+        var key = ChannelKey.FromDescriptor(channel.WithNormalizedCustomKey());
+
+        lock (_syncRoot)
+        {
+            if (!_mutedTokensByUser.TryGetValue(userUid, out var channels) ||
+                !channels.TryGetValue(key, out var tokens))
+            {
+                return false;
+            }
+
+            if (tokens.Contains(token))
+            {
+                return true;
+            }
+
+            if (_participantsByChannel.TryGetValue(key, out var participants) &&
+                participants.TryGetValue(token, out var participant))
+            {
+                return IsUIDMutedLocked(userUid, key, participant.UserUid);
+            }
+
+            return false;
+        }
+    }
+
+    public ChatMuteUpdateResult SetMutedParticipant(string userUid, ChatChannelDescriptor channel, ChatParticipantInfo participant, bool mute)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(userUid);
+        ArgumentException.ThrowIfNullOrEmpty(participant.Token);
+        ArgumentException.ThrowIfNullOrEmpty(participant.UserUid);
+
+        var key = ChannelKey.FromDescriptor(channel.WithNormalizedCustomKey());
+
+        lock (_syncRoot)
+        {
+            if (!_mutedTokensByUser.TryGetValue(userUid, out var channels))
+            {
+                if (!mute)
+                {
+                    return ChatMuteUpdateResult.NoChange;
+                }
+
+                channels = new Dictionary<ChannelKey, HashSet<string>>();
+                _mutedTokensByUser[userUid] = channels;
+            }
+
+            if (!channels.TryGetValue(key, out var tokens))
+            {
+                if (!mute)
+                {
+                    return ChatMuteUpdateResult.NoChange;
+                }
+
+                tokens = new HashSet<string>(StringComparer.Ordinal);
+                channels[key] = tokens;
+            }
+
+            if (mute)
+            {
+                if (!tokens.Contains(participant.Token) && tokens.Count >= MaxMutedParticipantsPerChannel)
+                {
+                    return ChatMuteUpdateResult.ChannelLimitReached;
+                }
+
+                var added = tokens.Add(participant.Token);
+                EnsureUIDMuteLocked(userUid, key, participant.UserUid);
+                return added ? ChatMuteUpdateResult.Changed : ChatMuteUpdateResult.NoChange;
+            }
+
+            var removed = tokens.Remove(participant.Token);
+            if (tokens.Count == 0)
+            {
+                channels.Remove(key);
+                if (channels.Count == 0)
+                {
+                    _mutedTokensByUser.Remove(userUid);
+                }
+            }
+
+            RemoveUIDMuteLocked(userUid, key, participant.UserUid);
+            return removed ? ChatMuteUpdateResult.Changed : ChatMuteUpdateResult.NoChange;
+        }
+    }
+
    private static string GenerateToken()
    {
        Span<byte> buffer = stackalloc byte[8];
@@ -458,4 +665,103 @@ public sealed class ChatChannelService

    private static string Describe(ChannelKey key)
        => $"{key.Type}:{key.WorldId}:{key.CustomKey}";
+
+    private void ClearMutesForChannel(string userUid, ChannelKey key)
+    {
+        if (_mutedTokensByUser.TryGetValue(userUid, out var tokenChannels) &&
+            tokenChannels.Remove(key) &&
+            tokenChannels.Count == 0)
+        {
+            _mutedTokensByUser.Remove(userUid);
+        }
+
+        if (_mutedUidsByUser.TryGetValue(userUid, out var uidChannels) &&
+            uidChannels.Remove(key) &&
+            uidChannels.Count == 0)
+        {
+            _mutedUidsByUser.Remove(userUid);
+        }
+    }
+
+    private void ApplyUIDMuteIfPresent(ChatChannelDescriptor descriptor, ChatParticipantInfo participant)
+    {
+        var key = ChannelKey.FromDescriptor(descriptor);
+        foreach (var kvp in _mutedUidsByUser)
+        {
+            var muter = kvp.Key;
+            var channels = kvp.Value;
+            if (!channels.TryGetValue(key, out var mutedUids) || !mutedUids.Contains(participant.UserUid))
+            {
+                continue;
+            }
+
+            if (!_mutedTokensByUser.TryGetValue(muter, out var tokenChannels))
+            {
+                tokenChannels = new Dictionary<ChannelKey, HashSet<string>>();
+                _mutedTokensByUser[muter] = tokenChannels;
+            }
+
+            if (!tokenChannels.TryGetValue(key, out var tokens))
+            {
+                tokens = new HashSet<string>(StringComparer.Ordinal);
+                tokenChannels[key] = tokens;
+            }
+
+            tokens.Add(participant.Token);
+        }
+    }
+
+    private void EnsureUIDMuteLocked(string userUid, ChannelKey key, string targetUid)
+    {
+        if (!_mutedUidsByUser.TryGetValue(userUid, out var channels))
+        {
+            channels = new Dictionary<ChannelKey, HashSet<string>>();
+            _mutedUidsByUser[userUid] = channels;
+        }
+
+        if (!channels.TryGetValue(key, out var set))
+        {
+            set = new HashSet<string>(StringComparer.Ordinal);
+            channels[key] = set;
+        }
+
+        set.Add(targetUid);
+    }
+
+    private void RemoveUIDMuteLocked(string userUid, ChannelKey key, string targetUid)
+    {
+        if (!_mutedUidsByUser.TryGetValue(userUid, out var channels) ||
+            !channels.TryGetValue(key, out var set))
+        {
+            return;
+        }
+
+        set.Remove(targetUid);
+        if (set.Count == 0)
+        {
+            channels.Remove(key);
+            if (channels.Count == 0)
+            {
+                _mutedUidsByUser.Remove(userUid);
+            }
+        }
+    }
+
+    private bool IsUIDMutedLocked(string userUid, ChannelKey key, string targetUid)
+    {
+        return _mutedUidsByUser.TryGetValue(userUid, out var channels) &&
+               channels.TryGetValue(key, out var set) &&
+               set.Contains(targetUid);
+    }
+
+    public void Dispose()
+    {
+    }
+}
+
+public enum ChatMuteUpdateResult
+{
+    NoChange,
+    Changed,
+    ChannelLimitReached
 }
--- a/LightlessSyncServer/LightlessSyncServer/Services/Interfaces/IPruneService.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Services/Interfaces/IPruneService.cs
@@ -0,0 +1,10 @@
+using LightlessSyncShared.Models;
+
+namespace LightlessSyncServer.Services.Interfaces
+{
+    public interface IPruneService
+    {
+        Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct);
+        Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct);
+    }
+}
--- a/LightlessSyncServer/LightlessSyncServer/Services/LightlessCensus.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Services/LightlessCensus.cs
@@ -72,7 +72,7 @@ public class LightlessCensus : IHostedService

        Dictionary<ushort, short> worldDcs = new();

-        var dcs = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/WorldDCGroupType.csv", cancellationToken).ConfigureAwait(false);
+        var dcs = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/WorldDCGroupType.csv", cancellationToken).ConfigureAwait(false);
        // dc: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/WorldDCGroupType.csv
        // id, name, region

@@ -92,7 +92,7 @@ public class LightlessCensus : IHostedService
            _dcs[id] = name;
        }

-        var worlds = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/World.csv", cancellationToken).ConfigureAwait(false);
+        var worlds = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/World.csv", cancellationToken).ConfigureAwait(false);
        // world: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/World.csv
        // id, internalname, name, region, usertype, datacenter, ispublic

@@ -114,7 +114,7 @@ public class LightlessCensus : IHostedService
            _logger.LogInformation("World: ID: {id}, Name: {name}, DC: {dc}", id, name, dc);
        }

-        var races = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Race.csv", cancellationToken).ConfigureAwait(false);
+        var races = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/Race.csv", cancellationToken).ConfigureAwait(false);
        // race: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Race.csv
        // id, masc name, fem name, other crap I don't care about

@@ -134,7 +134,7 @@ public class LightlessCensus : IHostedService
            _logger.LogInformation("Race: ID: {id}, Name: {name}", id, name);
        }

-        var tribe = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Tribe.csv", cancellationToken).ConfigureAwait(false);
+        var tribe = await client.GetStringAsync("https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/en/Tribe.csv", cancellationToken).ConfigureAwait(false);
        // tribe: https://raw.githubusercontent.com/xivapi/ffxiv-datamining/master/csv/Tribe.csv
        // id masc name, fem name, other crap I don't care about

--- a/LightlessSyncServer/LightlessSyncServer/Services/PruneService.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Services/PruneService.cs
@@ -0,0 +1,100 @@
+using LightlessSyncServer.Services.Interfaces;
+using LightlessSyncShared.Data;
+using LightlessSyncShared.Models;
+using Microsoft.EntityFrameworkCore;
+using StackExchange.Redis.Extensions.Core.Abstractions;
+
+namespace LightlessSyncServer.Services
+{
+    public class PruneService(LightlessDbContext dbContext, IRedisDatabase redis) : IPruneService
+    {
+        private readonly LightlessDbContext _dbContext = dbContext;
+        private readonly IRedisDatabase _redis = redis;
+
+        public async Task<int> CountPrunableUsersAsync(string groupGid, int days, CancellationToken ct)
+        {
+            var onlineUids = await GetOnlineUidsAsync().ConfigureAwait(false);
+
+            var allGroupUsers = await _dbContext.GroupPairs
+                .Include(p => p.GroupUser)
+                .Include(p => p.Group)
+                .Where(g => g.GroupGID == groupGid)
+                .ToListAsync(ct).ConfigureAwait(false);
+
+            var inactivitySpan = GetInactivitySpan(days);
+            var now = DateTime.UtcNow;
+
+            var usersToPrune = GetPruneUserList(allGroupUsers, onlineUids, inactivitySpan, now);
+            return usersToPrune.Count;
+        }
+
+        public async Task<IReadOnlyList<GroupPair>> ExecutePruneAsync(string groupGid, int days, CancellationToken ct)
+        {
+            var onlineUids = await GetOnlineUidsAsync().ConfigureAwait(false);
+
+            var allGroupUsers = await _dbContext.GroupPairs
+                .Include(p => p.GroupUser)
+                .Include(p => p.Group)
+                .Where(g => g.GroupGID == groupGid)
+                .ToListAsync(ct).ConfigureAwait(false);
+
+            var inactivitySpan = GetInactivitySpan(days);
+            var now = DateTime.UtcNow;
+
+            var usersToPrune = GetPruneUserList(allGroupUsers, onlineUids, inactivitySpan, now);
+
+            _dbContext.GroupPairs.RemoveRange(usersToPrune);
+            await _dbContext.SaveChangesAsync(ct).ConfigureAwait(false);
+
+            return usersToPrune;
+        }
+
+        private static List<GroupPair> GetPruneUserList(
+            List<GroupPair> allGroupUsers,
+            HashSet<string> onlineUids,
+            TimeSpan inactivitySpan,
+            DateTime now)
+        {
+            return
+            [
+                .. allGroupUsers.Where(p =>
+                    !p.IsPinned &&
+                    !p.IsModerator &&
+                    !string.Equals(p.Group.OwnerUID, p.GroupUserUID, StringComparison.Ordinal) &&
+                    !onlineUids.Contains(p.GroupUserUID) &&
+                    p.GroupUser.LastLoggedIn < now - inactivitySpan),
+            ];
+        }
+
+        private async Task<HashSet<string>> GetOnlineUidsAsync()
+        {
+            var keys = await _redis.SearchKeysAsync("UID:*").ConfigureAwait(false);
+
+            var set = new HashSet<string>(StringComparer.Ordinal);
+
+            foreach (var k in keys)
+            {
+                if (string.IsNullOrEmpty(k)) continue;
+
+                const string prefix = "UID:";
+                if (k.StartsWith(prefix, StringComparison.Ordinal))
+                {
+                    var uid = k.Substring(prefix.Length);
+                    if (!string.IsNullOrEmpty(uid))
+                        set.Add(uid);
+                }
+                else
+                {
+                    var idx = k.IndexOf(':', StringComparison.Ordinal);
+                    if (idx >= 0 && idx < k.Length - 1)
+                        set.Add(k[(idx + 1)..]);
+                }
+            }
+
+            return set;
+        }
+
+        private static TimeSpan GetInactivitySpan(int days) =>
+            days == 0 ? TimeSpan.FromHours(2) : TimeSpan.FromDays(days);
+    }
+}
--- a/LightlessSyncServer/LightlessSyncServer/Services/SystemInfoService.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Services/SystemInfoService.cs
@@ -72,9 +72,11 @@ public sealed class SystemInfoService : BackgroundService
                    await _hubContext.Clients.All.Client_UpdateSystemInfo(SystemInfoDto).ConfigureAwait(false);

                    using var db = await _dbContextFactory.CreateDbContextAsync(ct).ConfigureAwait(false);
+                    var groupsWithAutoPrune = db.Groups.AsNoTracking().Count(g => g.AutoPruneEnabled && g.AutoPruneDays > 0);

                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeAuthorizedConnections, onlineUsers);
                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeLightFinderConnections, countLightFinderUsers);
+                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroupAutoPrunesEnabled, groupsWithAutoPrune);
                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairs, db.ClientPairs.AsNoTracking().Count());
                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugePairsPaused, db.Permissions.AsNoTracking().Count(p => p.IsPaused));
                    _lightlessMetrics.SetGaugeTo(MetricsAPI.GaugeGroups, db.Groups.AsNoTracking().Count());
--- a/LightlessSyncServer/LightlessSyncServer/Startup.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Startup.cs
@@ -1,9 +1,13 @@
 using AspNetCoreRateLimit;
+using LightlessSync.API.Data;
+using LightlessSync.API.Dto.Group;
 using LightlessSync.API.SignalR;
-using LightlessSyncServer.Controllers;
 using LightlessSyncServer.Configuration;
+using LightlessSyncServer.Controllers;
 using LightlessSyncServer.Hubs;
 using LightlessSyncServer.Services;
+using LightlessSyncServer.Services.Interfaces;
+using LightlessSyncServer.Worker;
 using LightlessSyncShared.Data;
 using LightlessSyncShared.Metrics;
 using LightlessSyncShared.RequirementHandlers;
@@ -18,6 +22,7 @@ using Microsoft.AspNetCore.Http.Connections;
 using Microsoft.AspNetCore.Mvc.Controllers;
 using Microsoft.AspNetCore.SignalR;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.IdentityModel.Tokens;
 using Prometheus;
 using StackExchange.Redis;
@@ -88,6 +93,7 @@ public class Startup
        services.Configure<ServerConfiguration>(Configuration.GetRequiredSection("LightlessSync"));
        services.Configure<LightlessConfigurationBase>(Configuration.GetRequiredSection("LightlessSync"));
        services.Configure<BroadcastOptions>(Configuration.GetSection("Broadcast"));
+        services.Configure<ChatZoneOverridesOptions>(Configuration.GetSection("ChatZoneOverrides"));

        services.AddSingleton<IBroadcastConfiguration, BroadcastConfiguration>();
        services.AddSingleton<ServerTokenGenerator>();
@@ -109,9 +115,12 @@ public class Startup
            services.AddHostedService(provider => provider.GetService<CharaDataCleanupService>());
            services.AddHostedService<ClientPairPermissionsCleanupService>();
            services.AddScoped<PairService>();
+            services.AddScoped<IPruneService, PruneService>();
        }

        services.AddSingleton<GPoseLobbyDistributionService>();
+
+        services.AddHostedService<AutoPruneWorker>();
        services.AddHostedService(provider => provider.GetService<GPoseLobbyDistributionService>());
    }

@@ -120,6 +129,8 @@ public class Startup
        services.AddSingleton<IUserIdProvider, IdBasedUserIdProvider>();
        services.AddSingleton<ConcurrencyFilter>();

+        var msgpackOptions = MessagePackSerializerOptions.Standard.WithCompression(MessagePackCompression.Lz4Block).WithResolver(ContractlessStandardResolver.Instance);
+
        var signalRServiceBuilder = services.AddSignalR(hubOptions =>
        {
            hubOptions.MaximumReceiveMessageSize = long.MaxValue;
@@ -131,21 +142,10 @@ public class Startup
            hubOptions.AddFilter<ConcurrencyFilter>();
        }).AddMessagePackProtocol(opt =>
        {
-            var resolver = CompositeResolver.Create(StandardResolverAllowPrivate.Instance,
-                BuiltinResolver.Instance,
-                AttributeFormatterResolver.Instance,
-                // replace enum resolver
-                DynamicEnumAsStringResolver.Instance,
-                DynamicGenericResolver.Instance,
-                DynamicUnionResolver.Instance,
-                DynamicObjectResolver.Instance,
-                PrimitiveObjectResolver.Instance,
-                // final fallback(last priority)
-                StandardResolver.Instance);
+            opt.SerializerOptions = msgpackOptions;

-            opt.SerializerOptions = MessagePackSerializerOptions.Standard
-                .WithCompression(MessagePackCompression.Lz4Block)
-                .WithResolver(resolver);
+            var dummy = new GroupPruneSettingsDto(new GroupData("TEST-GID", null), true, 14);
+            MessagePackSerializer.Serialize(dummy, msgpackOptions);
        });


@@ -166,7 +166,7 @@ public class Startup
            KeyPrefix = "",
            Hosts = new RedisHost[]
            {
-                new RedisHost(){ Host = address, Port = port },
+                new(){ Host = address, Port = port },
            },
            AllowAdmin = true,
            ConnectTimeout = options.ConnectTimeout,
@@ -292,11 +292,12 @@ public class Startup
            MetricsAPI.CounterUserPairCacheMiss,
            MetricsAPI.CounterUserPairCacheNewEntries,
            MetricsAPI.CounterUserPairCacheUpdatedEntries,
-        }, new List<string>
-        {
+        },
+        [
            MetricsAPI.GaugeAuthorizedConnections,
            MetricsAPI.GaugeLightFinderConnections,
            MetricsAPI.GaugeLightFinderGroups,
+            MetricsAPI.GaugeGroupAutoPrunesEnabled,
            MetricsAPI.GaugeConnections,
            MetricsAPI.GaugePairs,
            MetricsAPI.GaugePairsPaused,
@@ -312,7 +313,7 @@ public class Startup
            MetricsAPI.GaugeGposeLobbyUsers,
            MetricsAPI.GaugeHubConcurrency,
            MetricsAPI.GaugeHubQueuedConcurrency,
-        }));
+        ]));
    }

    private static void ConfigureServicesBasedOnShardType(IServiceCollection services, IConfigurationSection lightlessConfig, bool isMainServer)
--- a/LightlessSyncServer/LightlessSyncServer/Utils/ChatMessageFilter.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Utils/ChatMessageFilter.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace LightlessSyncServer.Utils;
+
+internal static class ChatMessageFilter
+{
+    private static readonly Regex UrlRegex = new(@"\b(?:https?://|www\.)\S+", RegexOptions.IgnoreCase | RegexOptions.Compiled);
+
+    public static bool TryValidate(string? message, out string rejectionReason)
+    {
+        rejectionReason = string.Empty;
+        if (string.IsNullOrWhiteSpace(message))
+        {
+            return true;
+        }
+
+        if (UrlRegex.IsMatch(message))
+        {
+            rejectionReason = "Links are not permitted in chat.";
+            return false;
+        }
+
+        return true;
+    }
+}
--- a/LightlessSyncServer/LightlessSyncServer/Utils/Extensions.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Utils/Extensions.cs
@@ -22,6 +22,7 @@ public static class Extensions
        if (dto.Tags != null) profile.Tags = dto.Tags;
        if (dto.Description != null) profile.Description = dto.Description;
        if (dto.IsNsfw.HasValue) profile.IsNSFW = dto.IsNsfw.Value;
+        if (dto.IsDisabled.HasValue) profile.ProfileDisabled = dto.IsDisabled.Value;
    }

    public static void UpdateProfileFromDto(this UserProfileData profile, UserProfileDto dto, string? base64PictureString = null, string? base64BannerString = null)
@@ -117,6 +118,7 @@ public static class Extensions
        permissions.SetPreferDisableSounds(group.PreferDisableSounds);
        permissions.SetPreferDisableVFX(group.PreferDisableVFX);
        permissions.SetDisableInvites(!group.InvitesEnabled);
+        permissions.SetDisableChat(!group.ChatEnabled);
        return permissions;
    }

--- a/LightlessSyncServer/LightlessSyncServer/Utils/LightlessHubLogger.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Utils/LightlessHubLogger.cs
@@ -30,4 +30,14 @@ public class LightlessHubLogger
        string formattedArgs = args != null && args.Length != 0 ? "|" + string.Join(":", args) : string.Empty;
        _logger.LogWarning("{uid}:{method}{args}", _hub.UserUID, methodName, formattedArgs);
    }
+
+    public void LogError(Exception exception, string message, params object[] args)
+    {
+        _logger.LogError(exception, message, args);
+    }
+
+    public void LogError(string message, params object[] args)
+    {
+        _logger.LogError(message, args);
+    }
 }
--- a/LightlessSyncServer/LightlessSyncServer/Worker/AutoPruneWorker.cs
+++ b/LightlessSyncServer/LightlessSyncServer/Worker/AutoPruneWorker.cs
@@ -0,0 +1,68 @@
+using LightlessSync.API.Dto.Group;
+using LightlessSyncServer.Hubs;
+using LightlessSyncServer.Services.Interfaces;
+using LightlessSyncServer.Utils;
+using LightlessSyncShared.Data;
+using Microsoft.AspNetCore.SignalR;
+using Microsoft.EntityFrameworkCore;
+
+namespace LightlessSyncServer.Worker
+{
+    public class AutoPruneWorker(IServiceProvider services, ILogger<AutoPruneWorker> logger) : BackgroundService
+    {
+        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+        {
+            while (!stoppingToken.IsCancellationRequested)
+            {
+                try
+                {
+                    var scope = services.CreateAsyncScope();
+                    await using (scope.ConfigureAwait(false))
+                    {
+                        var db = scope.ServiceProvider.GetRequiredService<LightlessDbContext>();
+                        var pruneService = scope.ServiceProvider.GetRequiredService<IPruneService>();
+                        var hubContext = scope.ServiceProvider.GetRequiredService<IHubContext<LightlessHub>>();
+
+                        var groups = await db.Groups
+                            .Where(g => g.AutoPruneEnabled)
+                            .ToListAsync(stoppingToken).ConfigureAwait(false);
+
+                        foreach (var group in groups)
+                        {
+                            var allGroupUsers = await db.GroupPairs
+                                .Include(p => p.GroupUser)
+                                .Include(p => p.Group)
+                                .Where(p => p.GroupGID == group.GID)
+                                .ToListAsync(stoppingToken).ConfigureAwait(false);
+
+                            var prunedPairs = await pruneService.ExecutePruneAsync(group.GID, group.AutoPruneDays, stoppingToken).ConfigureAwait(false);
+
+                            if (prunedPairs.Count == 0)
+                                continue;
+
+                            var remainingUserIds = allGroupUsers
+                                .Where(p => !prunedPairs.Any(x => string.Equals(x.GroupUserUID, p.GroupUserUID, StringComparison.Ordinal)))
+                                .Select(p => p.GroupUserUID)
+                                .Distinct(StringComparer.Ordinal)
+                                .ToList();
+
+                            foreach (var pair in prunedPairs)
+                            {
+                                await hubContext.Clients.Users(remainingUserIds).SendAsync("Client_GroupPairLeft", new GroupPairDto(group.ToGroupData(), pair.GroupUser.ToUserData()), stoppingToken).ConfigureAwait(false);
+                            }
+
+                            logger.LogInformation("Auto-pruned {Count} users from group {GroupId}", prunedPairs.Count, group.GID);
+                        }
+                    }
+                }
+                catch (Exception ex)
+                {
+                    logger.LogError(ex, "Error in auto-prune worker");
+                }
+
+                //Run task each hour to check for pruning
+                await Task.Delay(TimeSpan.FromHours(1), stoppingToken).ConfigureAwait(false);
+            }
+        }
+    }
+}
--- a/LightlessSyncServer/LightlessSyncServer/appsettings.json
+++ b/LightlessSyncServer/LightlessSyncServer/appsettings.json
@@ -7,6 +7,7 @@
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information",
+      "Microsoft.EntityFrameworkCore.Database.Command": "Warning",
      "LightlessSyncServer.Authentication": "Warning",
      "System.IO.IOException": "Warning"
    },
@@ -40,6 +41,9 @@
    "PairRequestRateLimit": 5,
    "PairRequestRateWindow": 60
  },
+  "ChatZoneOverrides": {
+    "Zones": []
+  },
  "AllowedHosts": "*",
  "Kestrel": {
    "Endpoints": {
--- a/LightlessSyncServer/LightlessSyncServices/Discord/DiscordBot.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/DiscordBot.cs
@@ -1,9 +1,6 @@
-using System.Collections.Generic;
-using System;
 using System.Globalization;
 using System.Text;
 using System.Text.Json;
-using System.Linq;
 using Discord;
 using Discord.Interactions;
 using Discord.Rest;
@@ -162,7 +159,7 @@ internal class DiscordBot : IHostedService

            try
            {
-                await Task.Delay(TimeSpan.FromMinutes(10), token).ConfigureAwait(false);
+                await Task.Delay(TimeSpan.FromMinutes(1), token).ConfigureAwait(false);
            }
            catch (OperationCanceledException)
            {
@@ -204,7 +201,7 @@ internal class DiscordBot : IHostedService
            var embed = await BuildChatReportEmbedAsync(dbContext, report, token).ConfigureAwait(false);

            var components = new ComponentBuilder()
-                .WithButton("Actioned", $"{ChatReportButtonPrefix}-resolve-{report.ReportId}", ButtonStyle.Danger)
+                .WithButton("Resolve", $"{ChatReportButtonPrefix}-resolve-{report.ReportId}", ButtonStyle.Danger)
                .WithButton("Dismiss", $"{ChatReportButtonPrefix}-dismiss-{report.ReportId}", ButtonStyle.Secondary)
                .WithButton("Ban From Chat", $"{ChatReportButtonPrefix}-banchat-{report.ReportId}", ButtonStyle.Danger);

@@ -395,7 +392,7 @@ internal class DiscordBot : IHostedService
        switch (action)
        {
            case "resolve":
-                resolutionLabel = "Actioned";
+                resolutionLabel = "Resolved";
                break;
            case "dismiss":
                resolutionLabel = "Dismissed";
@@ -431,7 +428,7 @@ internal class DiscordBot : IHostedService

        string responseText = action switch
        {
-            "resolve" => "actioned",
+            "resolve" => "resolved",
            "dismiss" => "dismissed",
            "banchat" => "chat access revoked",
            _ => "processed"
@@ -473,7 +470,7 @@ internal class DiscordBot : IHostedService
        embedBuilder.Fields.RemoveAll(f => string.Equals(f.Name, "Resolution", StringComparison.OrdinalIgnoreCase));
        var resolutionText = action switch
        {
-            "resolve" => "Actioned",
+            "resolve" => "Resolved",
            "dismiss" => "Dismissed",
            "banchat" => "Chat access revoked",
            _ => "Processed"
@@ -872,16 +869,17 @@ internal class DiscordBot : IHostedService
        string? SenderHashedCid,
        string Message);

-    private async Task UpdateStatusAsync(CancellationToken token)
+    private async Task UpdateStatusAsync(CancellationToken cancellationToken)
    {
-        while (!token.IsCancellationRequested)
+        while (!cancellationToken.IsCancellationRequested)
        {
            var endPoint = _connectionMultiplexer.GetEndPoints().First();
-            var onlineUsers = await _connectionMultiplexer.GetServer(endPoint).KeysAsync(pattern: "UID:*").CountAsync().ConfigureAwait(false);
+            var keys = _connectionMultiplexer.GetServer(endPoint).KeysAsync(pattern: "UID:*");
+            var onlineUsers = await keys.CountAsync(cancellationToken).ConfigureAwait(false);

 			_logger.LogInformation("Users online: " + onlineUsers);
            await _discordClient.SetActivityAsync(new Game("Lightless for " + onlineUsers + " Users")).ConfigureAwait(false);
-            await Task.Delay(TimeSpan.FromSeconds(10)).ConfigureAwait(false);
+            await Task.Delay(TimeSpan.FromSeconds(10), cancellationToken).ConfigureAwait(false);
        }
    }
 }
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessModule.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessModule.cs
@@ -43,33 +43,54 @@ public class LightlessModule : InteractionModuleBase

        try
        {
-            EmbedBuilder eb = new();
-
            using var scope = _services.CreateScope();
            var db = scope.ServiceProvider.GetRequiredService<LightlessDbContext>();
            await using (db.ConfigureAwait(false))
            {
-                eb = await HandleUserInfo(eb, db, Context.User.Id, secondaryUid, discordUser?.Id ?? null, uid);
+                var (mainEmbed, profileEmbed) = await HandleUserInfo(db, Context.User.Id, secondaryUid, discordUser?.Id ?? null, uid);

                string uidToGet = await GetUserUID(db, secondaryUid, discordUser?.Id ?? null, uid).ConfigureAwait(false);
                var profileData = await GetUserProfileData(db, uidToGet).ConfigureAwait(false);
+                
+                List<Embed> embeds = new() { mainEmbed };
+                if (profileEmbed != null)
+                {
+                    embeds.Add(profileEmbed);
+                }
+
                if (profileData != null)
                {
                    byte[] profileImage = GetProfileImage(profileData);
                    byte[] bannerImage = GetBannerImage(profileData);
                    using MemoryStream profileImgStream = new(profileImage);
                    using MemoryStream bannerImgStream = new(bannerImage);
-                    eb.WithThumbnailUrl("attachment://profileimage.png");
-                    eb.WithImageUrl("attachment://bannerimage.png");
+                    
+                    var mainEmbedData = embeds[0];
+                    var mainEmbedBuilder = new EmbedBuilder()
+                        .WithTitle(mainEmbedData.Title)
+                        .WithDescription(mainEmbedData.Description)
+                        .WithThumbnailUrl("attachment://profileimage.png")
+                        .WithImageUrl("attachment://bannerimage.png");
+                    
+                    if (mainEmbedData.Fields != null)
+                    {
+                        foreach (var field in mainEmbedData.Fields)
+                        {
+                            mainEmbedBuilder.AddField(field.Name, field.Value, field.Inline);
+                        }
+                    }
+                    
+                    embeds[0] = mainEmbedBuilder.Build();
+                    
                    await RespondWithFilesAsync(
                        new[] { new FileAttachment(profileImgStream, "profileimage.png"), new FileAttachment(bannerImgStream, "bannerimage.png") },
-                        embeds: new[] { eb.Build() },
+                        embeds: embeds.ToArray(),
                        ephemeral: true).ConfigureAwait(false);
                } 
                else
                {
                    await RespondAsync(
-                        embeds: new[] { eb.Build() },
+                        embeds: embeds.ToArray(),
                        ephemeral: true).ConfigureAwait(false);
                }
            }
@@ -449,7 +470,7 @@ public class LightlessModule : InteractionModuleBase
        return embed.Build();
    }

-    private async Task<EmbedBuilder> HandleUserInfo(EmbedBuilder eb, LightlessDbContext db, ulong id, string? secondaryUserUid = null, ulong? optionalUser = null, string? uid = null)
+    private async Task<(Embed mainEmbed, Embed? profileEmbed)> HandleUserInfo(LightlessDbContext db, ulong id, string? secondaryUserUid = null, ulong? optionalUser = null, string? uid = null)
    {
        bool showForSecondaryUser = secondaryUserUid != null;

@@ -459,18 +480,20 @@ public class LightlessModule : InteractionModuleBase

        if (primaryUser == null)
        {
+            EmbedBuilder eb = new();
            eb.WithTitle("No account");
            eb.WithDescription("No Lightless account was found associated to your Discord user");
-            return eb;
+            return (eb.Build(), null);
        }

        bool isAdminCall = primaryUser.User.IsModerator || primaryUser.User.IsAdmin;

        if ((optionalUser != null || uid != null) && !isAdminCall)
        {
+            EmbedBuilder eb = new();
            eb.WithTitle("Unauthorized");
            eb.WithDescription("You are not authorized to view another users' information");
-            return eb;
+            return (eb.Build(), null);
        }
        else if ((optionalUser != null || uid != null) && isAdminCall)
        {
@@ -486,9 +509,10 @@ public class LightlessModule : InteractionModuleBase

            if (userInDb == null)
            {
+                EmbedBuilder eb = new();
                eb.WithTitle("No account");
                eb.WithDescription("The Discord user has no valid Lightless account");
-                return eb;
+                return (eb.Build(), null);
            }

            userToCheckForDiscordId = userInDb.DiscordId;
@@ -501,9 +525,10 @@ public class LightlessModule : InteractionModuleBase
            dbUser = (await db.Auth.Include(u => u.User).SingleOrDefaultAsync(u => u.PrimaryUserUID == dbUser.UID && u.UserUID == secondaryUserUid))?.User;
            if (dbUser == null)
            {
+                EmbedBuilder eb = new();
                eb.WithTitle("No such secondary UID");
                eb.WithDescription($"A secondary UID {secondaryUserUid} was not found attached to your primary UID {primaryUser.User.UID}.");
-                return eb;
+                return (eb.Build(), null);
            }
        }

@@ -513,55 +538,61 @@ public class LightlessModule : InteractionModuleBase
        var profile = await db.UserProfileData.Where(u => u.UserUID == dbUser.UID).SingleOrDefaultAsync().ConfigureAwait(false);
        var identity = await _connectionMultiplexer.GetDatabase().StringGetAsync("UID:" + dbUser.UID).ConfigureAwait(false);

-        eb.WithTitle("User Information");
-        eb.WithDescription("This is the user information for Discord User <@" + userToCheckForDiscordId + ">" + Environment.NewLine + Environment.NewLine
+        EmbedBuilder mainEmbed = new();
+        mainEmbed.WithTitle("User Information");
+        mainEmbed.WithDescription("This is the user information for Discord User <@" + userToCheckForDiscordId + ">" + Environment.NewLine + Environment.NewLine
            + "If you want to verify your secret key is valid, go to https://emn178.github.io/online-tools/sha256.html and copy your secret key into there and compare it to the Hashed Secret Key provided below.");
-        eb.AddField("UID", dbUser.UID);
+        mainEmbed.AddField("UID", dbUser.UID);
        if (!string.IsNullOrEmpty(dbUser.Alias))
        {
-            eb.AddField("Vanity UID", dbUser.Alias);
+            mainEmbed.AddField("Vanity UID", dbUser.Alias);
        }
        if (showForSecondaryUser)
        {
-            eb.AddField("Primary UID for " + dbUser.UID, auth.PrimaryUserUID);
+            mainEmbed.AddField("Primary UID for " + dbUser.UID, auth.PrimaryUserUID);
        }
        else
        {
            var secondaryUIDs = await db.Auth.Where(p => p.PrimaryUserUID == dbUser.UID).Select(p => p.UserUID).ToListAsync();
            if (secondaryUIDs.Any())
            {
-                eb.AddField("Secondary UIDs", string.Join(Environment.NewLine, secondaryUIDs));
+                mainEmbed.AddField("Secondary UIDs", string.Join(Environment.NewLine, secondaryUIDs));
            }
        }
-        if(profile != null)
-        {
-            eb.AddField("Profile Description", string.IsNullOrEmpty(profile.UserDescription) ? "(No description set)" : profile.UserDescription);
-            eb.AddField("Profile NSFW", profile.IsNSFW);
-            eb.AddField("Profile Disabled", profile.ProfileDisabled);
-            eb.AddField("Profile Flagged for Report", profile.FlaggedForReport);
-            eb.AddField("Profile Tags", profile.Tags != null && profile.Tags.Length > 0 ? string.Join(", ", profile.Tags) : "(No tags set)");
-        }
-        eb.AddField("Last Online (UTC)", dbUser.LastLoggedIn.ToString("U"));
-        eb.AddField("Currently online ", !string.IsNullOrEmpty(identity));
-        eb.AddField("Hashed Secret Key", auth.HashedKey);
-        eb.AddField("Joined Syncshells", groupsJoined.Count);
-        eb.AddField("Owned Syncshells", groups.Count);
+        mainEmbed.AddField("Last Online (UTC)", dbUser.LastLoggedIn.ToString("U"));
+        mainEmbed.AddField("Currently online ", !string.IsNullOrEmpty(identity));
+        mainEmbed.AddField("Hashed Secret Key", auth.HashedKey);
+        mainEmbed.AddField("Joined Syncshells", groupsJoined.Count);
+        mainEmbed.AddField("Owned Syncshells", groups.Count);
        foreach (var group in groups)
        {
            var syncShellUserCount = await db.GroupPairs.CountAsync(g => g.GroupGID == group.GID).ConfigureAwait(false);
            if (!string.IsNullOrEmpty(group.Alias))
            {
-                eb.AddField("Owned Syncshell " + group.GID + " Vanity ID", group.Alias);
+                mainEmbed.AddField("Owned Syncshell " + group.GID + " Vanity ID", group.Alias);
            }
-            eb.AddField("Owned Syncshell " + group.GID + " User Count", syncShellUserCount);
+            mainEmbed.AddField("Owned Syncshell " + group.GID + " User Count", syncShellUserCount);
        }

        if (isAdminCall && !string.IsNullOrEmpty(identity))
        {
-            eb.AddField("Character Ident", identity);
+            mainEmbed.AddField("Character Ident", identity);
        }

-        return eb;
+        Embed? profileEmbedResult = null;
+        if (profile != null)
+        {
+            EmbedBuilder profileEmbedBuilder = new();
+            profileEmbedBuilder.WithTitle("User Profile");
+            profileEmbedBuilder.WithDescription("Profile Description: " + (string.IsNullOrEmpty(profile.UserDescription) ? "(No description set)" : profile.UserDescription));
+            profileEmbedBuilder.AddField("Profile NSFW", profile.IsNSFW);
+            profileEmbedBuilder.AddField("Profile Disabled", profile.ProfileDisabled);
+            profileEmbedBuilder.AddField("Profile Flagged for Report", profile.FlaggedForReport);
+            profileEmbedBuilder.AddField("Profile Tags", profile.Tags != null && profile.Tags.Length > 0 ? string.Join(", ", profile.Tags) : "(No tags set)");
+            profileEmbedResult = profileEmbedBuilder.Build();
+        }
+
+        return (mainEmbed.Build(), profileEmbedResult);
    }

    private async Task<string> GetUserUID(LightlessDbContext db, string? secondaryUserUid = null, ulong? optionalUser = null, string? uid = null)
@@ -578,7 +609,7 @@ public class LightlessModule : InteractionModuleBase
            }
            else if (uid != null)
            {
-                userInDb = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.User.UID == uid || u.User.Alias == uid).ConfigureAwait(false);
+                userInDb = await db.LodeStoneAuth.Include(u => u.User).SingleOrDefaultAsync(u => u.User.UID == uid || u.User.Alias == uid). ConfigureAwait(false);
            }
            if (userInDb == null)
            {
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.AprilFools2024.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.AprilFools2024.cs
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Delete.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Delete.cs
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Recover.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Recover.cs
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Register.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Register.cs
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Relink.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Relink.cs
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Secondary.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Secondary.cs
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.UserInfo.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.UserInfo.cs
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Vanity.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.Vanity.cs
@@ -94,7 +94,7 @@ public partial class LightlessWizardModule
        bool canAddVanityId = !db.Users.Any(u => u.UID == modal.DesiredVanityUID || u.Alias == modal.DesiredVanityUID);
        var forbiddenWords = new[] { "null", "nil" };

-        Regex rgx = new(@"^[_\-a-zA-Z0-9]{3,15}$", RegexOptions.ECMAScript);
+        Regex rgx = new(@"^[_\-a-zA-Z0-9\?]{3,15}$", RegexOptions.ECMAScript);
        if (!rgx.Match(desiredVanityUid).Success)
        {
            eb.WithColor(Color.Red);
--- a/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.cs
+++ b/LightlessSyncServer/LightlessSyncServices/Discord/LightlessWizardModule.cs
--- a/LightlessSyncServer/LightlessSyncServices/LightlessSyncServices.csproj
+++ b/LightlessSyncServer/LightlessSyncServices/LightlessSyncServices.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

@@ -21,7 +21,7 @@
  </ItemGroup>

  <ItemGroup>
-    <PackageReference Include="Discord.Net" Version="3.17.0" />
+    <PackageReference Include="Discord.Net" Version="3.18.0" />
    <PackageReference Include="IDisposableAnalyzers" Version="4.0.8">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
@@ -32,6 +32,7 @@
    </PackageReference>
    <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.0" />
    <PackageReference Include="Microsoft.Extensions.Hosting.Systemd" Version="9.0.0" />
+    <PackageReference Include="System.Linq.Async" Version="7.0.0" />
  </ItemGroup>

  <ItemGroup>
--- a/LightlessSyncServer/LightlessSyncShared/Data/LightlessDbContext.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Data/LightlessDbContext.cs
@@ -80,6 +80,9 @@ public class LightlessDbContext : DbContext
        .WithOne(p => p.Group)
        .HasForeignKey<GroupProfile>(p => p.GroupGID)
        .IsRequired(false);
+        mb.Entity<Group>()
+        .Property(g => g.ChatEnabled)
+        .HasDefaultValue(true);
        mb.Entity<GroupPair>().ToTable("group_pairs");
        mb.Entity<GroupPair>().HasKey(u => new { u.GroupGID, u.GroupUserUID });
        mb.Entity<GroupPair>().HasIndex(c => c.GroupUserUID);
--- a/LightlessSyncServer/LightlessSyncShared/LightlessSyncShared.csproj
+++ b/LightlessSyncServer/LightlessSyncShared/LightlessSyncShared.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">

 	<PropertyGroup>
-		<TargetFramework>net9.0</TargetFramework>
+		<TargetFramework>net10.0</TargetFramework>
 		<ImplicitUsings>enable</ImplicitUsings>
 	</PropertyGroup>

@@ -47,7 +47,6 @@
 		<PackageReference Include="StackExchange.Redis.Extensions.Core" Version="10.2.0" />
 		<PackageReference Include="StackExchange.Redis.Extensions.System.Text.Json" Version="10.2.0" />
 		<PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="8.3.0" />
-		<PackageReference Include="System.Linq.Async" Version="6.0.1" />
 	</ItemGroup>

 	<ItemGroup>
--- a/LightlessSyncServer/LightlessSyncShared/Metrics/LightlessMetrics.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Metrics/LightlessMetrics.cs
--- a/LightlessSyncServer/LightlessSyncShared/Metrics/MetricsAPI.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Metrics/MetricsAPI.cs
@@ -11,6 +11,7 @@ public class MetricsAPI
    public const string CounterUsersRegisteredDeleted = "lightless_users_registered_deleted";
    public const string GaugeLightFinderConnections = "lightless_lightfinder_connections";
    public const string GaugeLightFinderGroups = "lightless_lightfinder_groups";
+    public const string GaugeGroupAutoPrunesEnabled = "lightless_group_autoprunes_enabled";
    public const string GaugePairs = "lightless_pairs";
    public const string GaugePairsPaused = "lightless_pairs_paused";
    public const string GaugeFilesTotal = "lightless_files";
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251205205537_AddAutoPruneInGroup.Designer.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251205205537_AddAutoPruneInGroup.Designer.cs
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251205205537_AddAutoPruneInGroup.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251205205537_AddAutoPruneInGroup.cs
@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddAutoPruneInGroup : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "auto_prune_days",
+                table: "groups",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "auto_prune_enabled",
+                table: "groups",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "auto_prune_days",
+                table: "groups");
+
+            migrationBuilder.DropColumn(
+                name: "auto_prune_enabled",
+                table: "groups");
+        }
+    }
+}
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251219115131_ChatReportFixes.Designer.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251219115131_ChatReportFixes.Designer.cs
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251219115131_ChatReportFixes.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251219115131_ChatReportFixes.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class ChatReportFixes : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "sender_token",
+                table: "reported_chat_messages");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "sender_token",
+                table: "reported_chat_messages",
+                type: "text",
+                nullable: false,
+                defaultValue: "");
+        }
+    }
+}
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.Designer.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.Designer.cs
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251222024252_DisableChatGroups.cs
@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class DisableChatGroups : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "chat_enabled",
+                table: "groups",
+                type: "boolean",
+                nullable: false,
+                defaultValue: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "chat_enabled",
+                table: "groups");
+        }
+    }
+}
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.Designer.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.Designer.cs
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/20251229015535_ShareLocation.cs
@@ -0,0 +1,30 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace LightlessSyncServer.Migrations
+{
+    /// <inheritdoc />
+    public partial class ShareLocation : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<DateTimeOffset>(
+                name: "share_location_until",
+                table: "user_permission_sets",
+                type: "timestamp with time zone",
+                nullable: false,
+                defaultValue: new DateTimeOffset(new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified), new TimeSpan(0, 0, 0, 0, 0)));
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "share_location_until",
+                table: "user_permission_sets");
+        }
+    }
+}
--- a/LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Migrations/LightlessDbContextModelSnapshot.cs
@@ -430,6 +430,20 @@ namespace LightlessSyncServer.Migrations
                        .HasColumnType("character varying(50)")
                        .HasColumnName("alias");

+                    b.Property<int>("AutoPruneDays")
+                        .HasColumnType("integer")
+                        .HasColumnName("auto_prune_days");
+
+                    b.Property<bool>("AutoPruneEnabled")
+                        .HasColumnType("boolean")
+                        .HasColumnName("auto_prune_enabled");
+
+                    b.Property<bool>("ChatEnabled")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("boolean")
+                        .HasDefaultValue(true)
+                        .HasColumnName("chat_enabled");
+
                    b.Property<DateTime>("CreatedDate")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("timestamp with time zone")
@@ -768,11 +782,6 @@ namespace LightlessSyncServer.Migrations
                        .HasColumnType("text")
                        .HasColumnName("sender_hashed_cid");

-                    b.Property<string>("SenderToken")
-                        .IsRequired()
-                        .HasColumnType("text")
-                        .HasColumnName("sender_token");
-
                    b.Property<bool>("SenderWasLightfinder")
                        .HasColumnType("boolean")
                        .HasColumnName("sender_was_lightfinder");
@@ -932,6 +941,10 @@ namespace LightlessSyncServer.Migrations
                        .HasColumnType("boolean")
                        .HasColumnName("is_paused");

+                    b.Property<DateTimeOffset>("ShareLocationUntil")
+                        .HasColumnType("timestamp with time zone")
+                        .HasColumnName("share_location_until");
+
                    b.Property<bool>("Sticky")
                        .HasColumnType("boolean")
                        .HasColumnName("sticky");
--- a/LightlessSyncServer/LightlessSyncShared/Models/Group.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Models/Group.cs
@@ -12,10 +12,13 @@ public class Group
    [MaxLength(50)]
    public string Alias { get; set; }
    public GroupProfile? Profile { get; set; }
+    public bool AutoPruneEnabled { get; set; } = false;
+    public int AutoPruneDays { get; set; } = 0;
    public bool InvitesEnabled { get; set; }
    public string HashedPassword { get; set; }
    public bool PreferDisableSounds { get; set; }
    public bool PreferDisableAnimations { get; set; }
    public bool PreferDisableVFX { get; set; }
+    public bool ChatEnabled { get; set; } = true;
    public DateTime CreatedDate { get; set; } = DateTime.UtcNow;
 }
--- a/LightlessSyncServer/LightlessSyncShared/Models/ReportedChatMessage.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Models/ReportedChatMessage.cs
@@ -40,9 +40,6 @@ public class ReportedChatMessage
    [Required]
    public string MessageContent { get; set; } = string.Empty;

-    [Required]
-    public string SenderToken { get; set; } = string.Empty;
-
    public string? SenderHashedCid { get; set; }

    public string? SenderDisplayName { get; set; }
--- a/LightlessSyncServer/LightlessSyncShared/Models/UserPermissionSet.cs
+++ b/LightlessSyncServer/LightlessSyncShared/Models/UserPermissionSet.cs
@@ -15,4 +15,5 @@ public class UserPermissionSet
    public bool DisableAnimations { get; set; } = false;
    public bool DisableVFX { get; set; } = false;
    public bool DisableSounds { get; set; } = false;
+    public DateTimeOffset ShareLocationUntil { get; set; } = DateTimeOffset.MinValue;
 }
--- a/LightlessSyncServer/LightlessSyncStaticFilesServer/LightlessSyncStaticFilesServer.csproj
+++ b/LightlessSyncServer/LightlessSyncStaticFilesServer/LightlessSyncStaticFilesServer.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">

  <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
  </PropertyGroup>

--- a/LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CachedFileProvider.cs
+++ b/LightlessSyncServer/LightlessSyncStaticFilesServer/Services/CachedFileProvider.cs
@@ -116,11 +116,12 @@ public sealed class CachedFileProvider : IDisposable
 			var tempFileName = destinationFilePath + ".dl";
 			File.Copy(coldStorageFilePath.FullName, tempFileName, true);
 			File.Move(tempFileName, destinationFilePath, true);
-            coldStorageFilePath.LastAccessTimeUtc = DateTime.UtcNow;
-            var destinationFile = new FileInfo(destinationFilePath);
-            destinationFile.LastAccessTimeUtc = DateTime.UtcNow;
-            destinationFile.CreationTimeUtc = DateTime.UtcNow;
-            destinationFile.LastWriteTimeUtc = DateTime.UtcNow;
+
+			File.SetLastAccessTimeUtc(coldStorageFilePath.FullName, DateTime.UtcNow);
+			File.SetLastAccessTimeUtc(destinationFilePath, DateTime.UtcNow);
+			File.SetCreationTimeUtc(destinationFilePath, DateTime.UtcNow);
+			File.SetLastWriteTimeUtc(destinationFilePath, DateTime.UtcNow);
+
 			_metrics.IncGauge(MetricsAPI.GaugeFilesTotal);
 			_metrics.IncGauge(MetricsAPI.GaugeFilesTotalSize, new FileInfo(destinationFilePath).Length);
 			return true;
@@ -173,7 +174,14 @@ public sealed class CachedFileProvider : IDisposable
 		var fi = FilePathUtil.GetFileInfoForHash(_hotStoragePath, hash);
 		if (fi == null) return null;

-        fi.LastAccessTimeUtc = DateTime.UtcNow;
+		try
+		{
+			File.SetLastAccessTimeUtc(fi.FullName, DateTime.UtcNow);
+		}
+		catch (Exception ex)
+		{
+			_logger.LogWarning(ex, "Failed to update LastAccessTimeUtc for file {hash}", hash);
+		}

 		_fileStatisticsService.LogFile(hash, fi.Length);
Author	SHA1	Message	Date
celine	e8c56bb3bc	Merge pull request 'Updated links for Xivapi sources' (#54 ) from xivapi-link-changes into master Reviewed-on: #54	2026-01-05 12:03:09 +00:00
celine	8e0dcc6792	Updated links for Xivapi sources	2026-01-05 12:01:53 +00:00
cake	ac4174f6e0	Fix moderator status on broadcast (#51 ) Co-authored-by: cake <admin@cakeandbanana.nl> Reviewed-on: #51 Co-authored-by: cake <cake@noreply.git.lightless-sync.org> Co-committed-by: cake <cake@noreply.git.lightless-sync.org>	2026-01-04 05:14:37 +00:00
cake	9fffaf7df2	fix-prune (#50 ) Co-authored-by: Tsubasahane <wozaiha@gmail.com> Co-authored-by: cake <admin@cakeandbanana.nl> Reviewed-on: #50 Co-authored-by: cake <cake@noreply.git.lightless-sync.org> Co-committed-by: cake <cake@noreply.git.lightless-sync.org>	2026-01-04 05:14:22 +00:00
cake	ca0c548373	AddBan changes for ban admin panel rework (#52 ) Co-authored-by: cake <admin@cakeandbanana.nl> Reviewed-on: #52 Co-authored-by: cake <cake@noreply.git.lightless-sync.org> Co-committed-by: cake <cake@noreply.git.lightless-sync.org>	2026-01-04 05:12:00 +00:00
Tsubasa	1716750347	Location Sharing (#49 ) Authored-by: Tsubasahane <wozaiha@gmail.com> Reviewed-on: #49 Co-authored-by: Tsubasa <tsubasa@noreply.git.lightless-sync.org> Co-committed-by: Tsubasa <tsubasa@noreply.git.lightless-sync.org>	2025-12-31 17:32:00 +00:00
defnotken	d39a922482	Merge pull request 'Trying a different method of setting access time.' (#48 ) from cache-test-fix into master Reviewed-on: #48	2025-12-23 17:14:08 +00:00
defnotken	6216664e18	Merge branch 'master' into cache-test-fix	2025-12-23 17:12:45 +00:00
defnotken	54992234d5	Merge pull request 'disable-chat-groups' (#45 ) from disable-chat-groups into master Reviewed-on: #45	2025-12-23 16:55:33 +00:00
defnotken	90e81fb955	Merge branch 'master' into disable-chat-groups	2025-12-23 16:55:21 +00:00
defnotken	4012b33f98	Trying a different method of setting access time.	2025-12-23 10:36:38 -06:00
defnotken	33fb6ba2eb	Merge pull request 'Done same for user' (#47 ) from fix-profile-hide into master Reviewed-on: #47	2025-12-22 20:31:36 +00:00
cake	d1526fa49e	Done same for user	2025-12-22 21:20:32 +01:00
defnotken	5b5f8edc3b	Merge pull request 'Removed code that would prevent changes on disabled profile.' (#46 ) from fix-profile-hide into master Reviewed-on: #46 Reviewed-by: defnotken <defnotken@noreply.git.lightless-sync.org>	2025-12-22 14:53:52 +00:00
cake	8515364ffd	Removed code that would prevent changes on disabled profile.	2025-12-22 15:46:52 +01:00
defnotken	4ec6169ebd	fix context	2025-12-21 21:02:59 -06:00
defnotken	ec26abaeb5	Revert "Merge pull request 'revert ce9b94a534c1239b4b89c4ccf05354c477da49d9' (#44 ) from defnotken-patch-1 into master" This reverts commit `76bdbe28da`, reversing changes made to `ce9b94a534`.	2025-12-21 21:00:53 -06:00
defnotken	3350f2ebf6	Merge branch 'master' into disable-chat-groups	2025-12-22 02:57:55 +00:00
defnotken	670e0e01f1	Merge branch 'disable-chat-groups' of https://git.lightless-sync.org/Lightless-Sync/LightlessServer into disable-chat-groups	2025-12-21 20:48:22 -06:00
defnotken	12d51dc689	Generate migration	2025-12-21 20:48:07 -06:00
defnotken	860bc955a4	Generate migration	2025-12-21 20:43:24 -06:00
defnotken	76bdbe28da	Merge pull request 'revert ce9b94a534c1239b4b89c4ccf05354c477da49d9' (#44 ) from defnotken-patch-1 into master Reviewed-on: #44	2025-12-22 02:27:14 +00:00
defnotken	f4753505aa	revert `ce9b94a534` revert Merge pull request 'add capability to disable chat feature for groups/syncshells' (#43) from disable-chat-groups into master Reviewed-on: #43	2025-12-22 02:25:40 +00:00
defnotken	ce9b94a534	Merge pull request 'add capability to disable chat feature for groups/syncshells' (#43 ) from disable-chat-groups into master Reviewed-on: #43	2025-12-22 02:18:00 +00:00
Abelfreyja	e58210e770	add capability to disable chat feature for groups/syncshells	2025-12-22 10:24:34 +09:00
defnotken	6d49389bd4	Merge pull request 'bump-api' (#42 ) from bump-api into master Reviewed-on: #42	2025-12-19 15:38:53 +00:00
defnotken	9a964b4933	Merge branch 'bump-api' of https://git.lightless-sync.org/Lightless-Sync/LightlessServer into bump-api	2025-12-19 09:37:49 -06:00
defnotken	2ca0fe0697	bumping tha api	2025-12-19 09:37:15 -06:00
defnotken	10bcf5dd1f	Merge pull request 'migration-fix' (#41 ) from migration-fix into master Reviewed-on: #41	2025-12-19 12:04:12 +00:00
defnotken	dda22594f1	db migration add for chat changes	2025-12-19 05:52:52 -06:00
defnotken	802077371b	fixed db migration for chat	2025-12-19 05:52:00 -06:00
defnotken	6321f385da	Discord-bot + server updates (#39 ) Co-authored-by: defnotken <itsdefnotken@gmail.com> Reviewed-on: #39 Co-authored-by: defnotken <defnotken@noreply.git.lightless-sync.org> Co-committed-by: defnotken <defnotken@noreply.git.lightless-sync.org>	2025-12-19 10:38:51 +00:00
cake	7cd463d4b7	bump api server	2025-12-19 07:12:09 +01:00
defnotken	dda45e8e73	Merge pull request 'Chat adjustment for release' (#38 ) from chat-adjustments into master Reviewed-on: #38	2025-12-18 21:19:55 +00:00
cake	7f01cc3661	bump api	2025-12-18 22:19:19 +01:00
azyges	67fe2a1f0f	just chat improvements :sludge:	2025-12-17 03:46:23 +09:00
azyges	1734f0e32f	Merge branch 'master' of https://git.lightless-sync.org/Lightless-Sync/LightlessServer into chat-adjustments	2025-12-17 00:14:40 +09:00
defnotken	2fb41d0b9f	Merge pull request 'Reduced content length of message, commented out the pending report.' (#37 ) from chat-changes into master Reviewed-on: #37 Reviewed-by: defnotken <defnotken@noreply.git.lightless-sync.org>	2025-12-16 12:00:08 +00:00
cake	6294b1d496	Reduced report chat messages to 1 min of polling	2025-12-16 07:11:35 +01:00
cake	143037165a	Reduced amount of chats, commented out the pending report.	2025-12-16 07:06:17 +01:00
azyges	989d079601	chat zone config, add more default zones	2025-12-14 15:55:32 +09:00
azyges	03ba9493fc	prevent report dodging by leaving channel, allow reports to work after leaving the channel too	2025-12-14 15:13:22 +09:00
defnotken	c731b265ff	Merge pull request 'Auto pruning of Syncshell, Added group count in DTO of group. Changed database to add prune days. Metrics added for auto prune enabled syncshells.' (#36 ) from auto-prune-syncshell into master Reviewed-on: #36 Reviewed-by: defnotken <defnotken@noreply.git.lightless-sync.org>	2025-12-09 05:37:42 +01:00
cake	5feb91ed42	updated api	2025-12-09 05:32:32 +01:00
cake	918c5e7d5d	Added disabled in the group profile dto.	2025-12-07 21:53:01 +01:00
cake	7748fa6eac	Back to an hourly action	2025-12-07 02:21:48 +01:00
cake	16c55d634d	Set minutes to 1 for testing.	2025-12-07 02:18:34 +01:00
cake	7c66d4c9cf	Update lightless api	2025-12-06 23:39:31 +01:00
cake	e21f9c36a4	Revert DTO, Changed messagepackprotocol again.	2025-12-06 23:39:24 +01:00
cake	c9d3cb0d50	Updated submodule	2025-12-06 22:58:36 +01:00
cake	2dc7681904	Changed resolver a bit for messagepack	2025-12-06 21:47:57 +01:00
cake	fb6ff4fb0e	Update	2025-12-06 20:16:09 +01:00
cake	903429e148	Merge branch 'auto-prune-syncshell' of https://git.lightless-sync.org/Lightless-Sync/LightlessServer into auto-prune-syncshell	2025-12-06 18:29:59 +01:00
cake	d7e5117e6b	Update	2025-12-06 18:02:45 +01:00
cake	727f27c2d1	Fixed some problems.	2025-12-06 18:02:39 +01:00
cake	3218e800d6	Merge branch 'master' into auto-prune-syncshell	2025-12-06 03:16:40 +01:00
cake	7e7a5808f4	Update submodule.	2025-12-05 22:01:58 +01:00
cake	091bfbbc29	Auto-pruning of syncshell, added metrics for pruning, return of count of users in fullgroupdto.	2025-12-05 22:01:48 +01:00
defnotken	00bcbbf8f4	Western Canadians will now filter to NA-East where servers are located in Canada. Co-authored-by: defnotken <itsdefnotken@gmail.com> Reviewed-on: #35	2025-11-20 19:33:53 +01:00