From 5996c4afce11249804d24f1caa3a99b390543c4d Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sat, 17 Jan 2026 17:10:07 +0100
Subject: Complete LinkedChildren integration and batch DTO optimizations

This commit integrates remaining performance changes:

- Add batch user data fetching in DtoService to reduce N+1 queries
- Add GetNextUpEpisodesBatch in TVSeriesManager for efficient batch retrieval
- Update Video/Movie/BoxSet to use LibraryManager for alternate versions
- Transition LinkedChild to use ItemId instead of Path (obsolete Path/LibraryItemId)
- Update providers and controllers for LinkedChildren-based references
- Add NextUpEpisodeBatchResult for batched episode queries
- Integrate IDescendantQueryProvider in SqliteDatabaseProvider
---
 .../Library/LibraryManager.cs                      | 119 ++++++++++++++++++---
 1 file changed, 107 insertions(+), 12 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index f7f5c387e1..2acfd68c36 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -406,6 +406,37 @@ namespace Emby.Server.Implementations.Library
                     item.Id);
             }
 
+            // If deleting a primary version video, clear PrimaryVersionId from alternate versions
+            if (item is Video video && string.IsNullOrEmpty(video.PrimaryVersionId))
+            {
+                var alternateVersions = GetLocalAlternateVersionIds(video)
+                    .Concat(GetLinkedAlternateVersions(video).Select(v => v.Id))
+                    .Distinct()
+                    .Select(id => GetItemById(id))
+                    .OfType<Video>()
+                    .ToList();
+
+                if (alternateVersions.Count > 0)
+                {
+                    _logger.LogInformation(
+                        "Clearing PrimaryVersionId from {Count} alternate versions of {Name}",
+                        alternateVersions.Count,
+                        item.Name ?? "Unknown name");
+
+                    // Promote the first alternate version to be the new primary
+                    var newPrimary = alternateVersions[0];
+                    newPrimary.SetPrimaryVersionId(null);
+                    newPrimary.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
+
+                    // Update remaining alternates to point to new primary
+                    foreach (var alternate in alternateVersions.Skip(1))
+                    {
+                        alternate.SetPrimaryVersionId(newPrimary.Id.ToString("N", CultureInfo.InvariantCulture));
+                        alternate.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
+                    }
+                }
+            }
+
             var children = item.IsFolder
                 ? ((Folder)item).GetRecursiveChildren(false)
                 : [];
@@ -576,6 +607,9 @@ namespace Emby.Server.Implementations.Library
                 // Trickplay
                 list.Add(_pathManager.GetTrickplayDirectory(video));
 
+                // Chapter Images
+                list.Add(_pathManager.GetChapterImageFolderPath(video));
+
                 // Subtitles and attachments
                 foreach (var mediaSource in item.GetMediaSources(false))
                 {
@@ -1421,14 +1455,7 @@ namespace Emby.Server.Implementations.Library
                 AddUserToQuery(query, query.User, allowExternalContent);
             }
 
-            var itemList = _itemRepository.GetItemList(query);
-            var user = query.User;
-            if (user is not null)
-            {
-                return itemList.Where(i => i.IsVisible(user)).ToList();
-            }
-
-            return itemList;
+            return _itemRepository.GetItemList(query);
         }
 
         public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query)
@@ -1474,6 +1501,11 @@ namespace Emby.Server.Implementations.Library
             return _itemRepository.GetItemCounts(query);
         }
 
+        public Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId)
+        {
+            return _itemRepository.GetChildCountBatch(parentIds, userId);
+        }
+
         public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query, List<BaseItem> parents)
         {
             SetTopParentIdsOrAncestors(query, parents);
@@ -1519,6 +1551,16 @@ namespace Emby.Server.Implementations.Library
             return _itemRepository.GetNextUpSeriesKeys(query, dateCutoff);
         }
 
+        /// <inheritdoc />
+        public IReadOnlyDictionary<string, MediaBrowser.Controller.Persistence.NextUpEpisodeBatchResult> GetNextUpEpisodesBatch(
+            InternalItemsQuery query,
+            IReadOnlyList<string> seriesKeys,
+            bool includeSpecials,
+            bool includeWatchedForRewatching)
+        {
+            return _itemRepository.GetNextUpEpisodesBatch(query, seriesKeys, includeSpecials, includeWatchedForRewatching);
+        }
+
         public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
         {
             if (query.User is not null)
@@ -1700,6 +1742,11 @@ namespace Emby.Server.Implementations.Library
 
         private void AddUserToQuery(InternalItemsQuery query, User user, bool allowExternalContent = true)
         {
+            if (query.User is null)
+            {
+                query.SetUser(user);
+            }
+
             if (query.AncestorIds.Length == 0 &&
                 query.ParentId.IsEmpty() &&
                 query.ChannelIds.Count == 0 &&
@@ -1725,6 +1772,15 @@ namespace Emby.Server.Implementations.Library
             }
         }
 
+        /// <inheritdoc/>
+        public void ConfigureUserAccess(InternalItemsQuery query, User user)
+        {
+            ArgumentNullException.ThrowIfNull(query);
+            ArgumentNullException.ThrowIfNull(user);
+
+            AddUserToQuery(query, user);
+        }
+
         private IEnumerable<Guid> GetTopParentIdsForQuery(BaseItem item, User? user)
         {
             if (item is UserView view)
@@ -1889,6 +1945,38 @@ namespace Emby.Server.Implementations.Library
             return video;
         }
 
+        /// <inheritdoc />
+        public IEnumerable<Guid> GetLocalAlternateVersionIds(Video video)
+        {
+            ArgumentNullException.ThrowIfNull(video);
+
+            var linkedIds = _itemRepository.GetLinkedChildrenIds(video.Id, (int)MediaBrowser.Controller.Entities.LinkedChildType.LocalAlternateVersion);
+            if (linkedIds.Count > 0)
+            {
+                return linkedIds;
+            }
+
+            return [];
+        }
+
+        /// <inheritdoc />
+        public IEnumerable<Video> GetLinkedAlternateVersions(Video video)
+        {
+            ArgumentNullException.ThrowIfNull(video);
+
+            var linkedIds = _itemRepository.GetLinkedChildrenIds(video.Id, (int)MediaBrowser.Controller.Entities.LinkedChildType.LinkedAlternateVersion);
+            if (linkedIds.Count > 0)
+            {
+                return linkedIds
+                    .Select(id => GetItemById(id))
+                    .Where(i => i is not null)
+                    .OfType<Video>()
+                    .OrderBy(i => i.SortName);
+            }
+
+            return [];
+        }
+
         /// <inheritdoc />
         public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User? user, IEnumerable<ItemSortBy> sortBy, SortOrder sortOrder)
         {
@@ -2896,10 +2984,17 @@ namespace Emby.Server.Implementations.Library
                     extra.ExtraType = extraType;
                 }
 
-                extra.ParentId = Guid.Empty;
-                extra.OwnerId = owner.Id;
-                extra.IsInMixedFolder = isInMixedFolder;
-                return extra;
+                // Only set OwnerId if this is actually an extra (not Unknown or null)
+                if (extra.ExtraType is not null)
+                {
+                    extra.ParentId = Guid.Empty;
+                    extra.OwnerId = owner.Id;
+                    extra.IsInMixedFolder = isInMixedFolder;
+
+                    return extra;
+                }
+
+                return null;
             }
         }
 
-- 
cgit v1.2.3


From 694db80d4c8e83ff381af56d2a3dde29e0855c3d Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 30 Jan 2026 21:58:24 +0100
Subject: Reroute on version removal

---
 .../Library/LibraryManager.cs                      | 15 +++++++++
 Jellyfin.Api/Controllers/VideosController.cs       |  3 ++
 .../Item/BaseItemRepository.cs                     | 39 ++++++++++++++++++++++
 MediaBrowser.Controller/Library/ILibraryManager.cs |  9 +++++
 .../Persistence/IItemRepository.cs                 | 17 ++++++++++
 5 files changed, 83 insertions(+)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 2acfd68c36..830c918541 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -428,6 +428,9 @@ namespace Emby.Server.Implementations.Library
                     newPrimary.SetPrimaryVersionId(null);
                     newPrimary.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
 
+                    // Re-route playlist/collection references from deleted primary to new primary
+                    _itemRepository.RerouteLinkedChildren(video.Id, newPrimary.Id);
+
                     // Update remaining alternates to point to new primary
                     foreach (var alternate in alternateVersions.Skip(1))
                     {
@@ -436,6 +439,12 @@ namespace Emby.Server.Implementations.Library
                     }
                 }
             }
+            else if (item is Video alternateVideo && !string.IsNullOrEmpty(alternateVideo.PrimaryVersionId)
+                && Guid.TryParse(alternateVideo.PrimaryVersionId, out var primaryId))
+            {
+                // If deleting an alternate version, re-route references to its primary
+                _itemRepository.RerouteLinkedChildren(alternateVideo.Id, primaryId);
+            }
 
             var children = item.IsFolder
                 ? ((Folder)item).GetRecursiveChildren(false)
@@ -3480,5 +3489,11 @@ namespace Emby.Server.Implementations.Library
             _fileSystem.CreateShortcut(lnk, _appHost.ReverseVirtualPath(path));
             RemoveContentTypeOverrides(path);
         }
+
+        /// <inheritdoc />
+        public int RerouteLinkedChildReferences(Guid fromChildId, Guid toChildId)
+        {
+            return _itemRepository.RerouteLinkedChildren(fromChildId, toChildId);
+        }
     }
 }
diff --git a/Jellyfin.Api/Controllers/VideosController.cs b/Jellyfin.Api/Controllers/VideosController.cs
index 2237e36b5f..1c8b695458 100644
--- a/Jellyfin.Api/Controllers/VideosController.cs
+++ b/Jellyfin.Api/Controllers/VideosController.cs
@@ -222,6 +222,9 @@ public class VideosController : BaseJellyfinApiController
 
             await item.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
 
+            // Re-route any playlist/collection references from this item to the primary
+            _libraryManager.RerouteLinkedChildReferences(item.Id, primaryVersion.Id);
+
             if (!alternateVersionsOfPrimary.Any(i => i.ItemId.HasValue && i.ItemId.Value.Equals(item.Id)))
             {
                 alternateVersionsOfPrimary.Add(new LinkedChild
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 9e6b100b66..22178e57f7 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -3843,4 +3843,43 @@ public sealed class BaseItemRepository
 
         return result;
     }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<Guid> GetManualLinkedParentIds(Guid childId)
+    {
+        using var context = _dbProvider.CreateDbContext();
+        return context.LinkedChildren
+            .Where(lc => lc.ChildId == childId && lc.ChildType == DbLinkedChildType.Manual)
+            .Select(lc => lc.ParentId)
+            .Distinct()
+            .ToList();
+    }
+
+    /// <inheritdoc/>
+    public int RerouteLinkedChildren(Guid fromChildId, Guid toChildId)
+    {
+        using var context = _dbProvider.CreateDbContext();
+
+        // Get parents that already reference toChildId (to avoid duplicates)
+        var parentsWithTarget = context.LinkedChildren
+            .Where(lc => lc.ChildId == toChildId && lc.ChildType == DbLinkedChildType.Manual)
+            .Select(lc => lc.ParentId)
+            .ToHashSet();
+
+        // Update references that won't create duplicates
+        var updated = context.LinkedChildren
+            .Where(lc => lc.ChildId == fromChildId
+                && lc.ChildType == DbLinkedChildType.Manual
+                && !parentsWithTarget.Contains(lc.ParentId))
+            .ExecuteUpdate(s => s.SetProperty(e => e.ChildId, toChildId));
+
+        // Remove references that would be duplicates
+        context.LinkedChildren
+            .Where(lc => lc.ChildId == fromChildId
+                && lc.ChildType == DbLinkedChildType.Manual
+                && parentsWithTarget.Contains(lc.ParentId))
+            .ExecuteDelete();
+
+        return updated;
+    }
 }
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index c19d15d85f..48859de04b 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -714,5 +714,14 @@ namespace MediaBrowser.Controller.Library
         /// <param name="virtualFolderPath">The path to the virtualfolder.</param>
         /// <param name="pathInfo">The new virtualfolder.</param>
         public void CreateShortcut(string virtualFolderPath, MediaPathInfo pathInfo);
+
+        /// <summary>
+        /// Re-routes LinkedChildren references from one child to another.
+        /// Used when video versions change to maintain playlist/BoxSet integrity.
+        /// </summary>
+        /// <param name="fromChildId">The child ID to re-route from.</param>
+        /// <param name="toChildId">The child ID to re-route to.</param>
+        /// <returns>Number of references updated.</returns>
+        int RerouteLinkedChildReferences(Guid fromChildId, Guid toChildId);
     }
 }
diff --git a/MediaBrowser.Controller/Persistence/IItemRepository.cs b/MediaBrowser.Controller/Persistence/IItemRepository.cs
index f7ed39730e..504adff86c 100644
--- a/MediaBrowser.Controller/Persistence/IItemRepository.cs
+++ b/MediaBrowser.Controller/Persistence/IItemRepository.cs
@@ -210,4 +210,21 @@ public interface IItemRepository
     /// <param name="userId">The user ID for access filtering.</param>
     /// <returns>Dictionary mapping parent ID to child count.</returns>
     Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId);
+
+    /// <summary>
+    /// Gets parent IDs (Playlists/BoxSets) that reference the specified child with LinkedChildType.Manual.
+    /// </summary>
+    /// <param name="childId">The child item ID.</param>
+    /// <returns>List of parent IDs that reference the child.</returns>
+    IReadOnlyList<Guid> GetManualLinkedParentIds(Guid childId);
+
+    /// <summary>
+    /// Updates LinkedChildren references from one child to another, preserving SortOrder.
+    /// Handles duplicates: if parent already references toChildId, removes the old reference instead.
+    /// Used when video versions change to maintain collection integrity.
+    /// </summary>
+    /// <param name="fromChildId">The child ID to re-route from.</param>
+    /// <param name="toChildId">The child ID to re-route to.</param>
+    /// <returns>Number of references updated.</returns>
+    int RerouteLinkedChildren(Guid fromChildId, Guid toChildId);
 }
-- 
cgit v1.2.3


From 2789532aa88ccc899ff8497537642e1d78b31ef5 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sat, 31 Jan 2026 19:19:26 +0100
Subject: Optimize Validator and Filter Performance

---
 .../Library/LibraryManager.cs                      |    6 +
 .../Library/Validators/ArtistsValidator.cs         |   12 +-
 .../Library/Validators/GenresValidator.cs          |   17 +-
 .../Library/Validators/StudiosValidator.cs         |   17 +-
 Jellyfin.Api/Controllers/FilterController.cs       |   44 +-
 .../Item/BaseItemRepository.cs                     |  139 +-
 .../Item/FolderAwareFilterExtensions.cs            |   47 +-
 .../Item/PeopleRepository.cs                       |    3 +-
 .../Users/UserManager.cs                           |    4 +-
 MediaBrowser.Controller/Library/ILibraryManager.cs |    7 +
 .../Persistence/IItemRepository.cs                 |    7 +
 .../ModelConfiguration/BaseItemConfiguration.cs    |    1 +
 .../PeopleBaseItemMapConfiguration.cs              |    1 +
 .../ModelConfiguration/UserDataConfiguration.cs    |    2 +
 ...20260130232147_AddBaseItemNameIndex.Designer.cs | 1801 ++++++++++++++++++++
 .../20260130232147_AddBaseItemNameIndex.cs         |   45 +
 .../Migrations/JellyfinDbModelSnapshot.cs          |    6 +
 17 files changed, 2072 insertions(+), 87 deletions(-)
 create mode 100644 src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260130232147_AddBaseItemNameIndex.Designer.cs
 create mode 100644 src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260130232147_AddBaseItemNameIndex.cs

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 830c918541..15705dee96 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -3495,5 +3495,11 @@ namespace Emby.Server.Implementations.Library
         {
             return _itemRepository.RerouteLinkedChildren(fromChildId, toChildId);
         }
+
+        /// <inheritdoc />
+        public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery query)
+        {
+            return _itemRepository.GetQueryFiltersLegacy(query);
+        }
     }
 }
diff --git a/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs b/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
index 8de3bff7ab..b196b1e038 100644
--- a/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
@@ -55,6 +55,8 @@ public class ArtistsValidator
             IncludeItemTypes = [BaseItemKind.MusicArtist]
         }).ToHashSet();
 
+        var existingArtists = _libraryManager.GetArtists(names);
+
         var numComplete = 0;
         var count = names.Count;
         var refreshed = 0;
@@ -63,7 +65,15 @@ public class ArtistsValidator
         {
             try
             {
-                var item = _libraryManager.GetArtist(name);
+                MusicArtist? item = null;
+                if (existingArtists.TryGetValue(name, out var artists) && artists.Length > 0)
+                {
+                    item = artists.OrderBy(i => i.IsAccessedByName ? 1 : 0).First();
+                }
+
+                // Fall back to GetArtist if not found (creates new item if needed)
+                item ??= _libraryManager.GetArtist(name);
+
                 if (!existingArtistIds.Contains(item.Id))
                 {
                     await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
diff --git a/Emby.Server.Implementations/Library/Validators/GenresValidator.cs b/Emby.Server.Implementations/Library/Validators/GenresValidator.cs
index 09ede8bb8d..badd6f1183 100644
--- a/Emby.Server.Implementations/Library/Validators/GenresValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/GenresValidator.cs
@@ -54,6 +54,13 @@ public class GenresValidator
             IncludeItemTypes = [BaseItemKind.Genre]
         }).ToHashSet();
 
+        var existingGenres = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Genre]
+        }).Cast<Genre>()
+        .GroupBy(g => g.Name, StringComparer.OrdinalIgnoreCase)
+        .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
+
         var numComplete = 0;
         var count = names.Count;
         var refreshed = 0;
@@ -62,7 +69,15 @@ public class GenresValidator
         {
             try
             {
-                var item = _libraryManager.GetGenre(name);
+                Genre? item = null;
+                if (existingGenres.TryGetValue(name, out var existingGenre))
+                {
+                    item = existingGenre;
+                }
+
+                // Fall back to GetGenre if not found (creates new item if needed)
+                item ??= _libraryManager.GetGenre(name);
+
                 if (!existingGenreIds.Contains(item.Id))
                 {
                     await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
diff --git a/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs b/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
index dd124feece..9fb6869171 100644
--- a/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
@@ -55,6 +55,13 @@ public class StudiosValidator
             IncludeItemTypes = [BaseItemKind.Studio]
         }).ToHashSet();
 
+        var existingStudios = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Studio]
+        }).Cast<Studio>()
+        .GroupBy(s => s.Name, StringComparer.OrdinalIgnoreCase)
+        .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
+
         var numComplete = 0;
         var count = names.Count;
         var refreshed = 0;
@@ -63,7 +70,15 @@ public class StudiosValidator
         {
             try
             {
-                var item = _libraryManager.GetStudio(name);
+                Studio? item = null;
+                if (existingStudios.TryGetValue(name, out var existingStudio))
+                {
+                    item = existingStudio;
+                }
+
+                // Fall back to GetStudio if not found (creates new item if needed)
+                item ??= _libraryManager.GetStudio(name);
+
                 if (!existingStudioIds.Contains(item.Id))
                 {
                     await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
diff --git a/Jellyfin.Api/Controllers/FilterController.cs b/Jellyfin.Api/Controllers/FilterController.cs
index 3f9aa93a64..5ad127ad8c 100644
--- a/Jellyfin.Api/Controllers/FilterController.cs
+++ b/Jellyfin.Api/Controllers/FilterController.cs
@@ -68,53 +68,27 @@ public class FilterController : BaseJellyfinApiController
             item = _libraryManager.GetParentItem(parentId, user?.Id);
         }
 
-        var query = new InternalItemsQuery
+        if (item is not Folder folder)
+        {
+            return new QueryFiltersLegacy();
+        }
+
+        var query = new InternalItemsQuery(user)
         {
-            User = user,
             MediaTypes = mediaTypes,
             IncludeItemTypes = includeItemTypes,
             Recursive = true,
             EnableTotalRecordCount = false,
+            AncestorIds = [folder.Id],
             DtoOptions = new DtoOptions
             {
-                Fields = new[] { ItemFields.Genres, ItemFields.Tags },
+                Fields = [],
                 EnableImages = false,
                 EnableUserData = false
             }
         };
 
-        if (item is not Folder folder)
-        {
-            return new QueryFiltersLegacy();
-        }
-
-        var itemList = folder.GetItemList(query);
-        return new QueryFiltersLegacy
-        {
-            Years = itemList.Select(i => i.ProductionYear ?? -1)
-                .Where(i => i > 0)
-                .Distinct()
-                .Order()
-                .ToArray(),
-
-            Genres = itemList.SelectMany(i => i.Genres)
-                .DistinctNames()
-                .Order()
-                .ToArray(),
-
-            Tags = itemList
-                .SelectMany(i => i.Tags)
-                .Distinct(StringComparer.OrdinalIgnoreCase)
-                .Order()
-                .ToArray(),
-
-            OfficialRatings = itemList
-                .Select(i => i.OfficialRating)
-                .Where(i => !string.IsNullOrWhiteSpace(i))
-                .Distinct(StringComparer.OrdinalIgnoreCase)
-                .Order()
-                .ToArray()
-        };
+        return _libraryManager.GetQueryFiltersLegacy(query);
     }
 
     /// <summary>
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 22178e57f7..55ef5972d4 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -993,7 +993,7 @@ public sealed class BaseItemRepository
             dbQuery = dbQuery.Include(e => e.Extras);
         }
 
-        return dbQuery;
+        return dbQuery.AsSingleQuery();
     }
 
     private IQueryable<BaseItemEntity> ApplyQueryPaging(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
@@ -1046,6 +1046,62 @@ public sealed class BaseItemRepository
         return dbQuery.Count();
     }
 
+    /// <inheritdoc />
+    public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        PrepareFilterQuery(filter);
+
+        using var context = _dbProvider.CreateDbContext();
+        var baseQuery = PrepareItemQuery(context, filter);
+        baseQuery = TranslateQuery(baseQuery, context, filter);
+
+        // Get matching item IDs as a subquery (not materialized)
+        var matchingItemIds = baseQuery.Select(e => e.Id);
+
+        // Query distinct years directly from the database
+        var years = baseQuery
+            .Where(e => e.ProductionYear != null && e.ProductionYear > 0)
+            .Select(e => e.ProductionYear!.Value)
+            .Distinct()
+            .OrderBy(y => y)
+            .ToArray();
+
+        // Query distinct official ratings directly from the database
+        var officialRatings = baseQuery
+            .Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)
+            .Select(e => e.OfficialRating!)
+            .Distinct()
+            .OrderBy(r => r)
+            .ToArray();
+
+        // Tags via ItemValuesMap JOIN - uses subquery for matching items
+        var tags = context.ItemValuesMap
+            .Where(ivm => ivm.ItemValue.Type == ItemValueType.Tags)
+            .Where(ivm => matchingItemIds.Contains(ivm.ItemId))
+            .Select(ivm => ivm.ItemValue.CleanValue)
+            .Distinct()
+            .OrderBy(t => t)
+            .ToArray();
+
+        // Genres via ItemValuesMap JOIN - uses subquery for matching items
+        var genres = context.ItemValuesMap
+            .Where(ivm => ivm.ItemValue.Type == ItemValueType.Genre)
+            .Where(ivm => matchingItemIds.Contains(ivm.ItemId))
+            .Select(ivm => ivm.ItemValue.CleanValue)
+            .Distinct()
+            .OrderBy(g => g)
+            .ToArray();
+
+        return new QueryFiltersLegacy
+        {
+            Years = years,
+            OfficialRatings = officialRatings,
+            Tags = tags,
+            Genres = genres
+        };
+    }
+
     /// <inheritdoc />
     public ItemCounts GetItemCounts(InternalItemsQuery filter)
     {
@@ -1229,8 +1285,6 @@ public sealed class BaseItemRepository
             }
         }
 
-        context.SaveChanges();
-
         var itemValueMaps = tuples
             .Select(e => (e.Item, Values: GetItemValuesToSave(e.Item, e.InheritedTags)))
             .ToArray();
@@ -1255,7 +1309,6 @@ public sealed class BaseItemRepository
             Value = f.Value
         }).ToArray();
         context.ItemValues.AddRange(missingItemValues);
-        context.SaveChanges();
 
         var itemValuesStore = existingValues.Concat(missingItemValues).ToArray();
         var valueMap = itemValueMaps
@@ -1291,8 +1344,6 @@ public sealed class BaseItemRepository
             context.ItemValuesMap.RemoveRange(itemMappedValues);
         }
 
-        context.SaveChanges();
-
         var itemsWithAncestors = tuples
             .Where(t => t.Item.SupportsAncestors && t.AncestorIds != null)
             .Select(t => t.Item.Id)
@@ -1619,7 +1670,8 @@ public sealed class BaseItemRepository
             .Include(e => e.LockedFields)
             .Include(e => e.UserData)
             .Include(e => e.Images)
-            .Include(e => e.LinkedChildEntities);
+            .Include(e => e.LinkedChildEntities)
+            .AsSingleQuery();
 
         var item = dbQuery.FirstOrDefault(e => e.Id == id);
         if (item is null)
@@ -2780,7 +2832,7 @@ public sealed class BaseItemRepository
         if (filter.TrailerTypes.Length > 0)
         {
             var trailerTypes = filter.TrailerTypes.Select(e => (int)e).ToArray();
-            baseQuery = baseQuery.Where(e => trailerTypes.Any(f => e.TrailerTypes!.Any(w => w.Id == f)));
+            baseQuery = baseQuery.Where(e => e.TrailerTypes!.Any(w => trailerTypes.Contains(w.Id)));
         }
 
         if (filter.IsAiring.HasValue)
@@ -2896,29 +2948,31 @@ public sealed class BaseItemRepository
 
         if (filter.IsFavoriteOrLiked.HasValue)
         {
+            var favoriteItemIds = context.UserData
+                .Where(ud => ud.UserId == filter.User!.Id && ud.IsFavorite)
+                .Select(ud => ud.ItemId);
             if (filter.IsFavoriteOrLiked.Value)
             {
-                baseQuery = baseQuery
-                    .Where(e => e.UserData!.Any(f => f.UserId == filter.User!.Id && f.IsFavorite));
+                baseQuery = baseQuery.Where(e => favoriteItemIds.Contains(e.Id));
             }
             else
             {
-                baseQuery = baseQuery
-                    .Where(e => !e.UserData!.Any(f => f.UserId == filter.User!.Id && f.IsFavorite));
+                baseQuery = baseQuery.Where(e => !favoriteItemIds.Contains(e.Id));
             }
         }
 
         if (filter.IsFavorite.HasValue)
         {
+            var favoriteItemIds = context.UserData
+                .Where(ud => ud.UserId == filter.User!.Id && ud.IsFavorite)
+                .Select(ud => ud.ItemId);
             if (filter.IsFavorite.Value)
             {
-                baseQuery = baseQuery
-                    .Where(e => e.UserData!.Any(f => f.UserId == filter.User!.Id && f.IsFavorite));
+                baseQuery = baseQuery.Where(e => favoriteItemIds.Contains(e.Id));
             }
             else
             {
-                baseQuery = baseQuery
-                    .Where(e => !e.UserData!.Any(f => f.UserId == filter.User!.Id && f.IsFavorite));
+                baseQuery = baseQuery.Where(e => !favoriteItemIds.Contains(e.Id));
             }
         }
 
@@ -2927,44 +2981,56 @@ public sealed class BaseItemRepository
             // We should probably figure this out for all folders, but for right now, this is the only place where we need it
             if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.Series)
             {
-                // Use subquery to find series with played episodes - stays in SQL instead of materializing to HashSet
-                var playedSeriesKeysSubquery = context.BaseItems
-                    .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesPresentationUniqueKey != null)
-                    .Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.Played))
-                    .Select(e => e.SeriesPresentationUniqueKey!);
+                // Get played series IDs by joining episodes to UserData via SeriesId (Guid foreign key).
+                // Don't filter episodes by TopParentIds here - the series will be filtered by baseQuery anyway.
+                // This allows the materialized list to be reused across library-scoped queries.
+                var playedSeriesIdList = context.BaseItems
+                    .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue)
+                    .Join(
+                        context.UserData.Where(ud => ud.UserId == filter.User!.Id && ud.Played),
+                        episode => episode.Id,
+                        ud => ud.ItemId,
+                        (episode, ud) => episode.SeriesId!.Value)
+                    .Distinct()
+                    .ToList();
 
                 if (filter.IsPlayed.Value)
                 {
-                    baseQuery = baseQuery.Where(e => playedSeriesKeysSubquery.Contains(e.PresentationUniqueKey!));
+                    baseQuery = baseQuery.Where(s => playedSeriesIdList.Contains(s.Id));
                 }
                 else
                 {
-                    baseQuery = baseQuery.Where(e => !playedSeriesKeysSubquery.Contains(e.PresentationUniqueKey!));
+                    baseQuery = baseQuery.Where(s => !playedSeriesIdList.Contains(s.Id));
                 }
             }
-            else if (filter.IsPlayed.Value)
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.UserData!.Any(f => f.UserId == filter.User!.Id && f.Played));
-            }
             else
             {
-                baseQuery = baseQuery
-                    .Where(e => !e.UserData!.Any(f => f.UserId == filter.User!.Id && f.Played));
+                var playedItemIds = context.UserData
+                    .Where(ud => ud.UserId == filter.User!.Id && ud.Played)
+                    .Select(ud => ud.ItemId);
+                if (filter.IsPlayed.Value)
+                {
+                    baseQuery = baseQuery.Where(e => playedItemIds.Contains(e.Id));
+                }
+                else
+                {
+                    baseQuery = baseQuery.Where(e => !playedItemIds.Contains(e.Id));
+                }
             }
         }
 
         if (filter.IsResumable.HasValue)
         {
+            var resumableItemIds = context.UserData
+                .Where(ud => ud.UserId == filter.User!.Id && ud.PlaybackPositionTicks > 0)
+                .Select(ud => ud.ItemId);
             if (filter.IsResumable.Value)
             {
-                baseQuery = baseQuery
-                       .Where(e => e.UserData!.Any(f => f.UserId == filter.User!.Id && f.PlaybackPositionTicks > 0));
+                baseQuery = baseQuery.Where(e => resumableItemIds.Contains(e.Id));
             }
             else
             {
-                baseQuery = baseQuery
-                       .Where(e => !e.UserData!.Any(f => f.UserId == filter.User!.Id && f.PlaybackPositionTicks > 0));
+                baseQuery = baseQuery.Where(e => !resumableItemIds.Contains(e.Id));
             }
         }
 
@@ -3681,9 +3747,12 @@ public sealed class BaseItemRepository
 
     private static (int Played, int Total) GetPlayedAndTotalCountFromQuery(IQueryable<BaseItemEntity> query, Guid userId)
     {
+        // GroupBy with a constant key aggregates all rows into a single group for server-side counting.
+        // OrderBy is required before FirstOrDefault to avoid EF Core warnings about unpredictable results.
         var result = query
             .Select(b => b.UserData!.Any(u => u.UserId == userId && u.Played))
-            .GroupBy(_ => 1) // Hack to aggregate over entire set
+            .GroupBy(_ => 1)
+            .OrderBy(g => g.Key)
             .Select(g => new
             {
                 Total = g.Count(),
diff --git a/Jellyfin.Server.Implementations/Item/FolderAwareFilterExtensions.cs b/Jellyfin.Server.Implementations/Item/FolderAwareFilterExtensions.cs
index d7b2567f37..888dacd16b 100644
--- a/Jellyfin.Server.Implementations/Item/FolderAwareFilterExtensions.cs
+++ b/Jellyfin.Server.Implementations/Item/FolderAwareFilterExtensions.cs
@@ -26,13 +26,25 @@ internal static class FolderAwareFilterExtensions
         JellyfinDbContext context,
         Expression<Func<BaseItemEntity, bool>> condition)
     {
-        // Use correlated Any() subqueries instead of UNION + Contains for better index utilization
-        var matchingIds = context.BaseItems.Where(condition).Select(b => b.Id);
+        // Get IDs of items that directly match the condition
+        var directMatchIds = context.BaseItems.Where(condition).Select(b => b.Id);
 
-        return query.Where(e =>
-            matchingIds.Contains(e.Id)
-            || context.AncestorIds.Any(a => a.ParentItemId == e.Id && matchingIds.Contains(a.ItemId))
-            || context.LinkedChildren.Any(lc => lc.ParentId == e.Id && matchingIds.Contains(lc.ChildId)));
+        // Get parent IDs where a descendant (via AncestorIds) matches
+        var ancestorMatchIds = context.AncestorIds
+            .Where(a => directMatchIds.Contains(a.ItemId))
+            .Select(a => a.ParentItemId);
+
+        // Get parent IDs where a linked child matches
+        var linkedMatchIds = context.LinkedChildren
+            .Where(lc => directMatchIds.Contains(lc.ChildId))
+            .Select(lc => lc.ParentId);
+
+        var allMatchingIds = directMatchIds
+            .Concat(ancestorMatchIds)
+            .Concat(linkedMatchIds)
+            .Distinct();
+
+        return query.Where(e => allMatchingIds.Contains(e.Id));
     }
 
     /// <summary>
@@ -48,11 +60,24 @@ internal static class FolderAwareFilterExtensions
         JellyfinDbContext context,
         Expression<Func<BaseItemEntity, bool>> condition)
     {
-        var matchingIds = context.BaseItems.Where(condition).Select(b => b.Id);
+        // Get IDs of items that directly match the condition
+        var directMatchIds = context.BaseItems.Where(condition).Select(b => b.Id);
+
+        // Get parent IDs where a descendant (via AncestorIds) matches
+        var ancestorMatchIds = context.AncestorIds
+            .Where(a => directMatchIds.Contains(a.ItemId))
+            .Select(a => a.ParentItemId);
+
+        // Get parent IDs where a linked child matches
+        var linkedMatchIds = context.LinkedChildren
+            .Where(lc => directMatchIds.Contains(lc.ChildId))
+            .Select(lc => lc.ParentId);
+
+        var allMatchingIds = directMatchIds
+            .Concat(ancestorMatchIds)
+            .Concat(linkedMatchIds)
+            .Distinct();
 
-        return query.Where(e =>
-            !matchingIds.Contains(e.Id)
-            && !context.AncestorIds.Any(a => a.ParentItemId == e.Id && matchingIds.Contains(a.ItemId))
-            && !context.LinkedChildren.Any(lc => lc.ParentId == e.Id && matchingIds.Contains(lc.ChildId)));
+        return query.Where(e => !allMatchingIds.Contains(e.Id));
     }
 }
diff --git a/Jellyfin.Server.Implementations/Item/PeopleRepository.cs b/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
index 355ed64797..022b452e85 100644
--- a/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
@@ -62,10 +62,9 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
         using var context = _dbProvider.CreateDbContext();
         var dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter).Select(e => e.Name).Distinct();
 
-        // dbQuery = dbQuery.OrderBy(e => e.ListOrder);
         if (filter.Limit > 0)
         {
-            dbQuery = dbQuery.Take(filter.Limit);
+            dbQuery = dbQuery.OrderBy(e => e).Take(filter.Limit);
         }
 
         return dbQuery.ToArray();
diff --git a/Jellyfin.Server.Implementations/Users/UserManager.cs b/Jellyfin.Server.Implementations/Users/UserManager.cs
index 501cb4fbe8..7292e9c7a9 100644
--- a/Jellyfin.Server.Implementations/Users/UserManager.cs
+++ b/Jellyfin.Server.Implementations/Users/UserManager.cs
@@ -93,7 +93,7 @@ namespace Jellyfin.Server.Implementations.Users
             _users = new ConcurrentDictionary<Guid, User>();
             using var dbContext = _dbProvider.CreateDbContext();
             foreach (var user in dbContext.Users
-                .AsSplitQuery()
+                .AsSingleQuery()
                 .Include(user => user.Permissions)
                 .Include(user => user.Preferences)
                 .Include(user => user.AccessSchedules)
@@ -607,6 +607,7 @@ namespace Jellyfin.Server.Implementations.Users
                                .Include(u => u.Preferences)
                                .Include(u => u.AccessSchedules)
                                .Include(u => u.ProfileImage)
+                               .AsSingleQuery()
                                .FirstOrDefault(u => u.Id.Equals(userId))
                            ?? throw new ArgumentException("No user exists with given Id!");
 
@@ -651,6 +652,7 @@ namespace Jellyfin.Server.Implementations.Users
                                .Include(u => u.Preferences)
                                .Include(u => u.AccessSchedules)
                                .Include(u => u.ProfileImage)
+                               .AsSingleQuery()
                                .FirstOrDefault(u => u.Id.Equals(userId))
                            ?? throw new ArgumentException("No user exists with given Id!");
 
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index 48859de04b..adb590ddbe 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -723,5 +723,12 @@ namespace MediaBrowser.Controller.Library
         /// <param name="toChildId">The child ID to re-route to.</param>
         /// <returns>Number of references updated.</returns>
         int RerouteLinkedChildReferences(Guid fromChildId, Guid toChildId);
+
+        /// <summary>
+        /// Gets legacy query filters for filtering UI.
+        /// </summary>
+        /// <param name="query">The query filter.</param>
+        /// <returns>Aggregated filter values.</returns>
+        QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery query);
     }
 }
diff --git a/MediaBrowser.Controller/Persistence/IItemRepository.cs b/MediaBrowser.Controller/Persistence/IItemRepository.cs
index 504adff86c..a063debbb5 100644
--- a/MediaBrowser.Controller/Persistence/IItemRepository.cs
+++ b/MediaBrowser.Controller/Persistence/IItemRepository.cs
@@ -218,6 +218,13 @@ public interface IItemRepository
     /// <returns>List of parent IDs that reference the child.</returns>
     IReadOnlyList<Guid> GetManualLinkedParentIds(Guid childId);
 
+    /// <summary>
+    /// Gets legacy query filters (Years, Genres, Tags, OfficialRatings) aggregated directly from the database.
+    /// </summary>
+    /// <param name="filter">The query filter.</param>
+    /// <returns>Aggregated filter values.</returns>
+    QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter);
+
     /// <summary>
     /// Updates LinkedChildren references from one child to another, preserving SortOrder.
     /// Handles duplicates: if parent already references toChildId, removes the old reference instead.
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/BaseItemConfiguration.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/BaseItemConfiguration.cs
index 4ec1b972dd..965da7ffd2 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/BaseItemConfiguration.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/BaseItemConfiguration.cs
@@ -36,6 +36,7 @@ public class BaseItemConfiguration : IEntityTypeConfiguration<BaseItemEntity>
         builder.HasIndex(e => e.Path);
         builder.HasIndex(e => e.ParentId);
         builder.HasIndex(e => e.OwnerId);
+        builder.HasIndex(e => e.Name);
         builder.HasIndex(e => e.ExtraType);
         builder.HasIndex(e => new { e.ExtraType, e.OwnerId });
         builder.HasIndex(e => e.PresentationUniqueKey);
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/PeopleBaseItemMapConfiguration.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/PeopleBaseItemMapConfiguration.cs
index f7694aeda0..32ede86c96 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/PeopleBaseItemMapConfiguration.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/PeopleBaseItemMapConfiguration.cs
@@ -15,6 +15,7 @@ public class PeopleBaseItemMapConfiguration : IEntityTypeConfiguration<PeopleBas
         builder.HasKey(e => new { e.ItemId, e.PeopleId, e.Role });
         builder.HasIndex(e => new { e.ItemId, e.SortOrder });
         builder.HasIndex(e => new { e.ItemId, e.ListOrder });
+        builder.HasIndex(e => e.PeopleId);
         builder.HasOne(e => e.Item);
         builder.HasOne(e => e.People);
     }
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/UserDataConfiguration.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/UserDataConfiguration.cs
index 223b2f8784..42848c6c4e 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/UserDataConfiguration.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/UserDataConfiguration.cs
@@ -18,6 +18,8 @@ public class UserDataConfiguration : IEntityTypeConfiguration<UserData>
         builder.HasIndex(d => new { d.ItemId, d.UserId, d.IsFavorite });
         builder.HasIndex(d => new { d.ItemId, d.UserId, d.LastPlayedDate });
         builder.HasIndex(d => new { d.UserId, d.ItemId, d.LastPlayedDate });
+        builder.HasIndex(d => new { d.UserId, d.Played, d.ItemId });
+        builder.HasIndex(d => new { d.UserId, d.IsFavorite, d.ItemId });
         builder.HasOne(e => e.Item).WithMany(e => e.UserData);
     }
 }
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260130232147_AddBaseItemNameIndex.Designer.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260130232147_AddBaseItemNameIndex.Designer.cs
new file mode 100644
index 0000000000..1b396a707c
--- /dev/null
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260130232147_AddBaseItemNameIndex.Designer.cs
@@ -0,0 +1,1801 @@
+// <auto-generated />
+using System;
+using Jellyfin.Database.Implementations;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Jellyfin.Database.Providers.Sqlite.Migrations
+{
+    [DbContext(typeof(JellyfinDbContext))]
+    [Migration("20260130232147_AddBaseItemNameIndex")]
+    partial class AddBaseItemNameIndex
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DayOfWeek")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("EndHour")
+                        .HasColumnType("REAL");
+
+                    b.Property<double>("StartHour")
+                        .HasColumnType("REAL");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccessSchedules");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ActivityLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LogSeverity")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Overview")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ShortOverview")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DateCreated");
+
+                    b.ToTable("ActivityLogs");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AncestorId", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ParentItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "ParentItemId");
+
+                    b.HasIndex("ParentItemId");
+
+                    b.ToTable("AncestorIds");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AttachmentStreamInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Filename")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MimeType")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "Index");
+
+                    b.ToTable("AttachmentStreamInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AlbumArtists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Artists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Audio")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("ChannelId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CleanName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("CommunityRating")
+                        .HasColumnType("REAL");
+
+                    b.Property<float?>("CriticRating")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("CustomRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastMediaAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastRefreshed")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastSaved")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EpisodeTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalSeriesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalServiceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ExtraType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ForcedSortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Genres")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("IndexNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("InheritedParentalRatingSubValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("InheritedParentalRatingValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsFolder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsInMixedFolder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsLocked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsMovie")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsRepeat")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsSeries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsVirtualItem")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<float?>("LUFS")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("MediaType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("NormalizationGain")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("OfficialRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("OwnerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentIndexNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredMetadataCountryCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredMetadataLanguage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("PremiereDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PresentationUniqueKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PrimaryVersionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProductionLocations")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ProductionYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("RunTimeTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("SeasonId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeasonName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("SeriesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesPresentationUniqueKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ShowId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("Size")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("StartDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Studios")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("TopParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TotalBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UnratedType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ExtraType");
+
+                    b.HasIndex("Name");
+
+                    b.HasIndex("OwnerId");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("Path");
+
+                    b.HasIndex("PresentationUniqueKey");
+
+                    b.HasIndex("ExtraType", "OwnerId");
+
+                    b.HasIndex("TopParentId", "Id");
+
+                    b.HasIndex("Type", "TopParentId", "Id");
+
+                    b.HasIndex("Type", "TopParentId", "PresentationUniqueKey");
+
+                    b.HasIndex("Type", "TopParentId", "StartDate");
+
+                    b.HasIndex("Id", "Type", "IsFolder", "IsVirtualItem");
+
+                    b.HasIndex("MediaType", "TopParentId", "IsVirtualItem", "PresentationUniqueKey");
+
+                    b.HasIndex("TopParentId", "IsFolder", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("TopParentId", "MediaType", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("TopParentId", "Type", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("Type", "SeriesPresentationUniqueKey", "IsFolder", "IsVirtualItem");
+
+                    b.HasIndex("Type", "SeriesPresentationUniqueKey", "PresentationUniqueKey", "SortName");
+
+                    b.HasIndex("IsFolder", "TopParentId", "IsVirtualItem", "PresentationUniqueKey", "DateCreated");
+
+                    b.HasIndex("Type", "TopParentId", "IsVirtualItem", "PresentationUniqueKey", "DateCreated");
+
+                    b.ToTable("BaseItems");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("00000000-0000-0000-0000-000000000001"),
+                            IsFolder = false,
+                            IsInMixedFolder = false,
+                            IsLocked = false,
+                            IsMovie = false,
+                            IsRepeat = false,
+                            IsSeries = false,
+                            IsVirtualItem = false,
+                            Name = "This is a placeholder item for UserData that has been detached from its original item",
+                            Type = "PLACEHOLDER"
+                        });
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemImageInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Blurhash")
+                        .HasColumnType("BLOB");
+
+                    b.Property<DateTime?>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ImageType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemId");
+
+                    b.HasIndex("ItemId", "ImageType");
+
+                    b.ToTable("BaseItemImageInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemMetadataField", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("BaseItemMetadataFields");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemProvider", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderValue")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "ProviderId");
+
+                    b.HasIndex("ProviderId", "ProviderValue", "ItemId");
+
+                    b.ToTable("BaseItemProviders");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemTrailerType", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("BaseItemTrailerTypes");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Chapter", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChapterIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("ImageDateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ImagePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("StartPositionTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "ChapterIndex");
+
+                    b.ToTable("Chapters");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.CustomItemDisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "ItemId", "Client", "Key")
+                        .IsUnique();
+
+                    b.ToTable("CustomItemDisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChromecastVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DashboardTheme")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EnableNextVideoInfoOverlay")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("IndexBy")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ScrollDirection")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowBackdrop")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowSidebar")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SkipBackwardLength")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SkipForwardLength")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TvHome")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "ItemId", "Client")
+                        .IsUnique();
+
+                    b.ToTable("DisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.HomeSection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DisplayPreferencesId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DisplayPreferencesId");
+
+                    b.ToTable("HomeSection");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ImageInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("ImageInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemDisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("IndexBy")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RememberIndexing")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberSorting")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortBy")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ViewType")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("ItemDisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValue", b =>
+                {
+                    b.Property<Guid>("ItemValueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CleanValue")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemValueId");
+
+                    b.HasIndex("Type", "CleanValue");
+
+                    b.HasIndex("Type", "Value")
+                        .IsUnique();
+
+                    b.ToTable("ItemValues");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValueMap", b =>
+                {
+                    b.Property<Guid>("ItemValueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemValueId", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("ItemValuesMap");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.KeyframeData", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.PrimitiveCollection<string>("KeyframeTicks")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("TotalDuration")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId");
+
+                    b.ToTable("KeyframeData");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.LinkedChildEntity", b =>
+                {
+                    b.Property<Guid>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ChildId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChildType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ParentId", "ChildId");
+
+                    b.HasIndex("ChildId");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("ChildId", "ChildType");
+
+                    b.HasIndex("ParentId", "ChildType");
+
+                    b.HasIndex("ParentId", "SortOrder");
+
+                    b.ToTable("LinkedChildren", (string)null);
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaSegment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("EndTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SegmentProviderId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("StartTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MediaSegments");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaStreamInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AspectRatio")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("AverageFrameRate")
+                        .HasColumnType("REAL");
+
+                    b.Property<int?>("BitDepth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("BitRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("BlPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ChannelLayout")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Channels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTimeBase")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorPrimaries")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorSpace")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorTransfer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DvBlSignalCompatibilityId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvLevel")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvProfile")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvVersionMajor")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvVersionMinor")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ElPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("Hdr10PlusPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsAnamorphic")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsAvc")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsExternal")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsForced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsHearingImpaired")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsInterlaced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("KeyFrames")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("Level")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("NalLengthSize")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PixelFormat")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Profile")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("RealFrameRate")
+                        .HasColumnType("REAL");
+
+                    b.Property<int?>("RefFrames")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Rotation")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RpuPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SampleRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StreamType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TimeBase")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "StreamIndex");
+
+                    b.HasIndex("StreamIndex");
+
+                    b.HasIndex("StreamType");
+
+                    b.HasIndex("StreamIndex", "StreamType");
+
+                    b.HasIndex("StreamIndex", "StreamType", "Language");
+
+                    b.ToTable("MediaStreamInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.People", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PersonType")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name");
+
+                    b.ToTable("Peoples");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.PeopleBaseItemMap", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("PeopleId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ListOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "PeopleId", "Role");
+
+                    b.HasIndex("PeopleId");
+
+                    b.HasIndex("ItemId", "ListOrder");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("PeopleBaseItemMap");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Permission", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("Permission_Permissions_Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Value")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "Kind")
+                        .IsUnique()
+                        .HasFilter("[UserId] IS NOT NULL");
+
+                    b.ToTable("Permissions");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("Preference_Preferences_Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(65535)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "Kind")
+                        .IsUnique()
+                        .HasFilter("[UserId] IS NOT NULL");
+
+                    b.ToTable("Preferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateLastActivity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccessToken")
+                        .IsUnique();
+
+                    b.ToTable("ApiKeys");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.Device", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AppName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AppVersion")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateLastActivity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceId");
+
+                    b.HasIndex("AccessToken", "DateLastActivity");
+
+                    b.HasIndex("DeviceId", "DateLastActivity");
+
+                    b.HasIndex("UserId", "DeviceId");
+
+                    b.ToTable("Devices");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.DeviceOptions", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CustomName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceId")
+                        .IsUnique();
+
+                    b.ToTable("DeviceOptions");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.TrickplayInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Bandwidth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Interval")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ThumbnailCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TileHeight")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TileWidth")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "Width");
+
+                    b.ToTable("TrickplayInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AudioLanguagePreference")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthenticationProviderId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CastReceiverId")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DisplayCollectionsView")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("DisplayMissingEpisodes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableAutoLogin")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableLocalPassword")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableNextEpisodeAutoPlay")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableUserPreferenceAccess")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("HidePlayedInLatest")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("InternalId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InvalidLoginAttemptCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastActivityDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastLoginDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("LoginAttemptsBeforeLockout")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxActiveSessions")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MaxParentalRatingScore")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MaxParentalRatingSubScore")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("MustUpdatePassword")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Password")
+                        .HasMaxLength(65535)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordResetProviderId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PlayDefaultAudioTrack")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberAudioSelections")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberSubtitleSelections")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RemoteClientBitrateLimit")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SubtitleLanguagePreference")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SyncPlayAccess")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.UserData", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CustomDataKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("AudioStreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsFavorite")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastPlayedDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool?>("Likes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("PlaybackPositionTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Played")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double?>("Rating")
+                        .HasColumnType("REAL");
+
+                    b.Property<DateTime?>("RetentionDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SubtitleStreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "UserId", "CustomDataKey");
+
+                    b.HasIndex("ItemId", "UserId", "IsFavorite");
+
+                    b.HasIndex("ItemId", "UserId", "LastPlayedDate");
+
+                    b.HasIndex("ItemId", "UserId", "PlaybackPositionTicks");
+
+                    b.HasIndex("ItemId", "UserId", "Played");
+
+                    b.HasIndex("UserId", "IsFavorite", "ItemId");
+
+                    b.HasIndex("UserId", "ItemId", "LastPlayedDate");
+
+                    b.HasIndex("UserId", "Played", "ItemId");
+
+                    b.ToTable("UserData");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("AccessSchedules")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AncestorId", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Parents")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "ParentItem")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("ParentItem");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AttachmentStreamInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Owner")
+                        .WithMany("Extras")
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "DirectParent")
+                        .WithMany("DirectChildren")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("DirectParent");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemImageInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Images")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemMetadataField", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("LockedFields")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemProvider", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Provider")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemTrailerType", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("TrailerTypes")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Chapter", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("DisplayPreferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.HomeSection", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.DisplayPreferences", null)
+                        .WithMany("HomeSections")
+                        .HasForeignKey("DisplayPreferencesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ImageInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithOne("ProfileImage")
+                        .HasForeignKey("Jellyfin.Database.Implementations.Entities.ImageInfo", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemDisplayPreferences", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("ItemDisplayPreferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValueMap", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("ItemValues")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.ItemValue", "ItemValue")
+                        .WithMany("BaseItemsMap")
+                        .HasForeignKey("ItemValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("ItemValue");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.KeyframeData", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.LinkedChildEntity", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Child")
+                        .WithMany("LinkedChildOfEntities")
+                        .HasForeignKey("ChildId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Parent")
+                        .WithMany("LinkedChildEntities")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Child");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaStreamInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("MediaStreams")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.PeopleBaseItemMap", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Peoples")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.People", "People")
+                        .WithMany("BaseItems")
+                        .HasForeignKey("PeopleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("People");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Permission", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("Permissions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Preference", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("Preferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.Device", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.UserData", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("UserData")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.Navigation("Chapters");
+
+                    b.Navigation("Children");
+
+                    b.Navigation("DirectChildren");
+
+                    b.Navigation("Extras");
+
+                    b.Navigation("Images");
+
+                    b.Navigation("ItemValues");
+
+                    b.Navigation("LinkedChildEntities");
+
+                    b.Navigation("LinkedChildOfEntities");
+
+                    b.Navigation("LockedFields");
+
+                    b.Navigation("MediaStreams");
+
+                    b.Navigation("Parents");
+
+                    b.Navigation("Peoples");
+
+                    b.Navigation("Provider");
+
+                    b.Navigation("TrailerTypes");
+
+                    b.Navigation("UserData");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.Navigation("HomeSections");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValue", b =>
+                {
+                    b.Navigation("BaseItemsMap");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.People", b =>
+                {
+                    b.Navigation("BaseItems");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.User", b =>
+                {
+                    b.Navigation("AccessSchedules");
+
+                    b.Navigation("DisplayPreferences");
+
+                    b.Navigation("ItemDisplayPreferences");
+
+                    b.Navigation("Permissions");
+
+                    b.Navigation("Preferences");
+
+                    b.Navigation("ProfileImage");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260130232147_AddBaseItemNameIndex.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260130232147_AddBaseItemNameIndex.cs
new file mode 100644
index 0000000000..da57c71662
--- /dev/null
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260130232147_AddBaseItemNameIndex.cs
@@ -0,0 +1,45 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Jellyfin.Database.Providers.Sqlite.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddBaseItemNameIndex : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_UserData_UserId_IsFavorite_ItemId",
+                table: "UserData",
+                columns: new[] { "UserId", "IsFavorite", "ItemId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_UserData_UserId_Played_ItemId",
+                table: "UserData",
+                columns: new[] { "UserId", "Played", "ItemId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_BaseItems_Name",
+                table: "BaseItems",
+                column: "Name");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_UserData_UserId_IsFavorite_ItemId",
+                table: "UserData");
+
+            migrationBuilder.DropIndex(
+                name: "IX_UserData_UserId_Played_ItemId",
+                table: "UserData");
+
+            migrationBuilder.DropIndex(
+                name: "IX_BaseItems_Name",
+                table: "BaseItems");
+        }
+    }
+}
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
index c7d884f15e..865091530b 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
@@ -362,6 +362,8 @@ namespace Jellyfin.Server.Implementations.Migrations
 
                     b.HasIndex("ExtraType");
 
+                    b.HasIndex("Name");
+
                     b.HasIndex("OwnerId");
 
                     b.HasIndex("ParentId");
@@ -1446,8 +1448,12 @@ namespace Jellyfin.Server.Implementations.Migrations
 
                     b.HasIndex("ItemId", "UserId", "Played");
 
+                    b.HasIndex("UserId", "IsFavorite", "ItemId");
+
                     b.HasIndex("UserId", "ItemId", "LastPlayedDate");
 
+                    b.HasIndex("UserId", "Played", "ItemId");
+
                     b.ToTable("UserData");
 
                     b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
-- 
cgit v1.2.3


From a0346fe5b70a434860f973086be176ecc2018a52 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 5 Feb 2026 00:17:44 +0100
Subject: Fix multiple version handling

---
 .../Library/LibraryManager.cs                      | 74 +++++++++++++++++++++-
 .../Item/BaseItemRepository.cs                     | 54 +++++++++++++++-
 .../Migrations/Routines/MigrateLinkedChildren.cs   | 58 +++++++++++++++++
 MediaBrowser.Controller/Entities/BaseItem.cs       | 11 +++-
 MediaBrowser.Controller/Entities/Movies/Movie.cs   | 19 ++++++
 MediaBrowser.Controller/Entities/Video.cs          | 33 +++++++++-
 MediaBrowser.Controller/Library/ILibraryManager.cs |  9 +++
 .../Persistence/IItemRepository.cs                 | 10 +++
 8 files changed, 260 insertions(+), 8 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 15705dee96..38aec6d491 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -1986,6 +1986,12 @@ namespace Emby.Server.Implementations.Library
             return [];
         }
 
+        /// <inheritdoc />
+        public void UpsertLinkedChild(Guid parentId, Guid childId, MediaBrowser.Controller.Entities.LinkedChildType childType)
+        {
+            _itemRepository.UpsertLinkedChild(parentId, childId, childType);
+        }
+
         /// <inheritdoc />
         public IEnumerable<BaseItem> Sort(IEnumerable<BaseItem> items, User? user, IEnumerable<ItemSortBy> sortBy, SortOrder sortOrder)
         {
@@ -2090,9 +2096,40 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public void CreateItems(IReadOnlyList<BaseItem> items, BaseItem? parent, CancellationToken cancellationToken)
         {
-            _itemRepository.SaveItems(items, cancellationToken);
-
+            // Resolve and add any local alternate version items that don't exist yet
+            // This ensures they exist in the database when LinkedChildren are processed
+            var allItems = new List<BaseItem>(items);
             foreach (var item in items)
+            {
+                if (item is Video video && video.LocalAlternateVersions.Length > 0)
+                {
+                    var videoType = video.GetType();
+                    foreach (var path in video.LocalAlternateVersions)
+                    {
+                        if (string.IsNullOrEmpty(path))
+                        {
+                            continue;
+                        }
+
+                        // Use the primary video's type for ID calculation to ensure consistency
+                        var altId = GetNewItemId(path, videoType);
+                        if (GetItemById(altId) is null && !allItems.Any(i => i.Id.Equals(altId)))
+                        {
+                            // Alternate version doesn't exist, resolve and create it
+                            var altVideo = ResolvePath(_fileSystem.GetFileSystemInfo(path)) as Video;
+                            if (altVideo is not null)
+                            {
+                                altVideo.OwnerId = video.Id;
+                                allItems.Add(altVideo);
+                            }
+                        }
+                    }
+                }
+            }
+
+            _itemRepository.SaveItems(allItems, cancellationToken);
+
+            foreach (var item in allItems)
             {
                 RegisterItem(item);
             }
@@ -2258,7 +2295,38 @@ namespace Emby.Server.Implementations.Library
                 item.DateLastSaved = DateTime.UtcNow;
             }
 
-            _itemRepository.SaveItems(items, cancellationToken);
+            // Resolve and add any local alternate version items that don't exist yet
+            // This ensures they exist in the database when LinkedChildren are processed
+            var allItems = new List<BaseItem>(items);
+            foreach (var item in items)
+            {
+                if (item is Video video && video.LocalAlternateVersions.Length > 0)
+                {
+                    var videoType = video.GetType();
+                    foreach (var path in video.LocalAlternateVersions)
+                    {
+                        if (string.IsNullOrEmpty(path))
+                        {
+                            continue;
+                        }
+
+                        // Use the primary video's type for ID calculation to ensure consistency
+                        var altId = GetNewItemId(path, videoType);
+                        if (GetItemById(altId) is null && !allItems.Any(i => i.Id.Equals(altId)))
+                        {
+                            // Alternate version doesn't exist, resolve and create it
+                            var altVideo = ResolvePath(_fileSystem.GetFileSystemInfo(path)) as Video;
+                            if (altVideo is not null)
+                            {
+                                altVideo.OwnerId = video.Id;
+                                allItems.Add(altVideo);
+                            }
+                        }
+                    }
+                }
+            }
+
+            _itemRepository.SaveItems(allItems, cancellationToken);
 
             if (parent is Folder folder)
             {
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index b154592e6e..76769c33e7 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -1599,10 +1599,35 @@ public sealed class BaseItemRepository
                     }
                 }
 
-                // Remove orphaned alternate version links
+                // Remove orphaned alternate version links and their items
                 if (existingLinkedChildren.Count > 0)
                 {
+                    // Get the child IDs of LocalAlternateVersions that are being removed
+                    // These items should be deleted as they are owned by this video
+                    var orphanedLocalVersionIds = existingLinkedChildren
+                        .Where(e => e.ChildType == DbLinkedChildType.LocalAlternateVersion)
+                        .Select(e => e.ChildId)
+                        .ToList();
+
                     context.LinkedChildren.RemoveRange(existingLinkedChildren);
+
+                    // Delete the orphaned LocalAlternateVersion items themselves
+                    if (orphanedLocalVersionIds.Count > 0)
+                    {
+                        var orphanedItems = context.BaseItems
+                            .Where(e => orphanedLocalVersionIds.Contains(e.Id) && e.OwnerId == video.Id)
+                            .ToList();
+
+                        if (orphanedItems.Count > 0)
+                        {
+                            _logger.LogInformation(
+                                "Deleting {Count} orphaned LocalAlternateVersion items for video {VideoName} ({VideoId})",
+                                orphanedItems.Count,
+                                video.Name,
+                                video.Id);
+                            context.BaseItems.RemoveRange(orphanedItems);
+                        }
+                    }
                 }
             }
         }
@@ -3942,4 +3967,31 @@ public sealed class BaseItemRepository
 
         return updated;
     }
+
+    /// <inheritdoc/>
+    public void UpsertLinkedChild(Guid parentId, Guid childId, LinkedChildType childType)
+    {
+        using var context = _dbProvider.CreateDbContext();
+
+        var dbChildType = (DbLinkedChildType)childType;
+        var existingLink = context.LinkedChildren
+            .FirstOrDefault(lc => lc.ParentId == parentId && lc.ChildId == childId);
+
+        if (existingLink is null)
+        {
+            context.LinkedChildren.Add(new LinkedChildEntity
+            {
+                ParentId = parentId,
+                ChildId = childId,
+                ChildType = dbChildType,
+                SortOrder = null
+            });
+        }
+        else
+        {
+            existingLink.ChildType = dbChildType;
+        }
+
+        context.SaveChanges();
+    }
 }
diff --git a/Jellyfin.Server/Migrations/Routines/MigrateLinkedChildren.cs b/Jellyfin.Server/Migrations/Routines/MigrateLinkedChildren.cs
index 15108a07b4..d08d1a4efd 100644
--- a/Jellyfin.Server/Migrations/Routines/MigrateLinkedChildren.cs
+++ b/Jellyfin.Server/Migrations/Routines/MigrateLinkedChildren.cs
@@ -182,6 +182,18 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
 
             if (toInsert.Count > 0)
             {
+                // Deduplicate by composite key (ParentId, ChildId)
+                // Priority: LocalAlternateVersion > LinkedAlternateVersion > Other
+                toInsert = toInsert
+                    .OrderBy(lc => lc.ChildType switch
+                    {
+                        LinkedChildType.LocalAlternateVersion => 0,
+                        LinkedChildType.LinkedAlternateVersion => 1,
+                        _ => 2
+                    })
+                    .DistinctBy(lc => new { lc.ParentId, lc.ChildId })
+                    .ToList();
+
                 var childIds = toInsert.Select(lc => lc.ChildId).Distinct().ToList();
                 var existingChildIds = context.BaseItems
                     .Where(b => childIds.Contains(b.Id))
@@ -207,9 +219,55 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
 
         _logger.LogInformation("LinkedChildren migration completed. Processed {Count} items.", processedCount);
 
+        UpdateAlternateVersionTypes(context);
         CleanupOrphanedLinkedChildren(context);
     }
 
+    private void UpdateAlternateVersionTypes(JellyfinDbContext context)
+    {
+        _logger.LogInformation("Updating alternate version item types to match their parent's type...");
+
+        // Find all LocalAlternateVersion relationships where the child is a generic Video
+        // but the parent is a more specific type (like Movie)
+        var genericVideoType = "MediaBrowser.Controller.Entities.Video";
+
+        var alternateVersionsToUpdate = context.LinkedChildren
+            .Where(lc => lc.ChildType == LinkedChildType.LocalAlternateVersion)
+            .Join(
+                context.BaseItems,
+                lc => lc.ParentId,
+                parent => parent.Id,
+                (lc, parent) => new { lc.ChildId, ParentType = parent.Type })
+            .Join(
+                context.BaseItems,
+                x => x.ChildId,
+                child => child.Id,
+                (x, child) => new { x.ChildId, x.ParentType, ChildType = child.Type, Child = child })
+            .Where(x => x.ChildType == genericVideoType && x.ParentType != genericVideoType)
+            .ToList();
+
+        if (alternateVersionsToUpdate.Count == 0)
+        {
+            _logger.LogInformation("No alternate version items need type updates.");
+            return;
+        }
+
+        _logger.LogInformation("Found {Count} alternate version items to update.", alternateVersionsToUpdate.Count);
+
+        foreach (var item in alternateVersionsToUpdate)
+        {
+            item.Child.Type = item.ParentType;
+            _logger.LogDebug(
+                "Updating item {ChildId} type from {OldType} to {NewType}",
+                item.ChildId,
+                genericVideoType,
+                item.ParentType);
+        }
+
+        context.SaveChanges();
+        _logger.LogInformation("Successfully updated {Count} alternate version item types.", alternateVersionsToUpdate.Count);
+    }
+
     private void CleanupOrphanedLinkedChildren(JellyfinDbContext context)
     {
         _logger.LogInformation("Starting cleanup of orphaned LinkedChildren records...");
diff --git a/MediaBrowser.Controller/Entities/BaseItem.cs b/MediaBrowser.Controller/Entities/BaseItem.cs
index f1c1555842..3f04b1ffae 100644
--- a/MediaBrowser.Controller/Entities/BaseItem.cs
+++ b/MediaBrowser.Controller/Entities/BaseItem.cs
@@ -1430,10 +1430,15 @@ namespace MediaBrowser.Controller.Entities
                 });
                 foreach (var removedExtra in removedExtras)
                 {
-                    LibraryManager.DeleteItem(removedExtra, new DeleteOptions()
+                    // Only delete items that are actual extras (have ExtraType set)
+                    // Items with OwnerId but no ExtraType might be alternate versions, not extras
+                    if (removedExtra.ExtraType.HasValue)
                     {
-                        DeleteFileLocation = false
-                    });
+                        LibraryManager.DeleteItem(removedExtra, new DeleteOptions()
+                        {
+                            DeleteFileLocation = false
+                        });
+                    }
                 }
             }
 
diff --git a/MediaBrowser.Controller/Entities/Movies/Movie.cs b/MediaBrowser.Controller/Entities/Movies/Movie.cs
index 797f44e2d5..5ab149a49d 100644
--- a/MediaBrowser.Controller/Entities/Movies/Movie.cs
+++ b/MediaBrowser.Controller/Entities/Movies/Movie.cs
@@ -9,8 +9,10 @@ using System.Text.Json.Serialization;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.Controller.Entities.Movies
 {
@@ -91,6 +93,20 @@ namespace MediaBrowser.Controller.Entities.Movies
             };
 
             var id = LibraryManager.GetNewItemId(path, typeof(Movie));
+
+            // Check if the file still exists
+            if (!FileSystem.FileExists(path))
+            {
+                // File was removed - clean up any orphaned database entry
+                if (LibraryManager.GetItemById(id) is Movie orphanedMovie && orphanedMovie.OwnerId.Equals(Id))
+                {
+                    Logger.LogInformation("Alternate version file no longer exists, removing orphaned item: {Path}", path);
+                    LibraryManager.DeleteItem(orphanedMovie, new DeleteOptions { DeleteFileLocation = false });
+                }
+
+                return;
+            }
+
             if (LibraryManager.GetItemById(id) is not Movie movie)
             {
                 movie = LibraryManager.ResolvePath(FileSystem.GetFileSystemInfo(path)) as Movie;
@@ -109,6 +125,9 @@ namespace MediaBrowser.Controller.Entities.Movies
             }
 
             await RefreshMetadataForOwnedItem(movie, copyTitleMetadata, newOptions, cancellationToken).ConfigureAwait(false);
+
+            // Create LinkedChild entry for this local alternate version
+            LibraryManager.UpsertLinkedChild(Id, movie.Id, LinkedChildType.LocalAlternateVersion);
         }
 
         /// <inheritdoc />
diff --git a/MediaBrowser.Controller/Entities/Video.cs b/MediaBrowser.Controller/Entities/Video.cs
index 1ddc193359..21aa50b49d 100644
--- a/MediaBrowser.Controller/Entities/Video.cs
+++ b/MediaBrowser.Controller/Entities/Video.cs
@@ -19,6 +19,7 @@ using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.MediaInfo;
+using Microsoft.Extensions.Logging;
 
 namespace MediaBrowser.Controller.Entities
 {
@@ -428,6 +429,17 @@ namespace MediaBrowser.Controller.Entities
         {
             var hasChanges = await base.RefreshedOwnedItems(options, fileSystemChildren, cancellationToken).ConfigureAwait(false);
 
+            // Clean up LocalAlternateVersions - remove paths that no longer exist
+            if (LocalAlternateVersions.Length > 0)
+            {
+                var validPaths = LocalAlternateVersions.Where(FileSystem.FileExists).ToArray();
+                if (validPaths.Length != LocalAlternateVersions.Length)
+                {
+                    LocalAlternateVersions = validPaths;
+                    hasChanges = true;
+                }
+            }
+
             if (IsStacked)
             {
                 var tasks = AdditionalParts
@@ -467,7 +479,21 @@ namespace MediaBrowser.Controller.Entities
                 SearchResult = null
             };
 
-            var id = LibraryManager.GetNewItemId(path, typeof(Video));
+            var id = LibraryManager.GetNewItemId(path, GetType());
+
+            // Check if the file still exists
+            if (!FileSystem.FileExists(path))
+            {
+                // File was removed - clean up any orphaned database entry
+                if (LibraryManager.GetItemById(id) is Video orphanedVideo && orphanedVideo.OwnerId.Equals(Id))
+                {
+                    Logger.LogInformation("Owned video file no longer exists, removing orphaned item: {Path}", path);
+                    LibraryManager.DeleteItem(orphanedVideo, new DeleteOptions { DeleteFileLocation = false });
+                }
+
+                return;
+            }
+
             if (LibraryManager.GetItemById(id) is not Video video)
             {
                 video = LibraryManager.ResolvePath(FileSystem.GetFileSystemInfo(path)) as Video;
@@ -486,6 +512,11 @@ namespace MediaBrowser.Controller.Entities
             }
 
             await RefreshMetadataForOwnedItem(video, copyTitleMetadata, newOptions, cancellationToken).ConfigureAwait(false);
+
+            // Create LinkedChild entry for this local alternate version
+            // This ensures the relationship exists in the database even if the alternate version
+            // was created after the primary video was first saved
+            LibraryManager.UpsertLinkedChild(Id, video.Id, LinkedChildType.LocalAlternateVersion);
         }
 
         private void RefreshLinkedAlternateVersions()
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index adb590ddbe..9b46dec3fe 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -20,6 +20,7 @@ using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Querying;
 using Episode = MediaBrowser.Controller.Entities.TV.Episode;
 using Genre = MediaBrowser.Controller.Entities.Genre;
+using LinkedChildType = MediaBrowser.Controller.Entities.LinkedChildType;
 using Person = MediaBrowser.Controller.Entities.Person;
 
 namespace MediaBrowser.Controller.Library
@@ -229,6 +230,14 @@ namespace MediaBrowser.Controller.Library
         /// <returns>Enumerable of linked Video items.</returns>
         IEnumerable<Video> GetLinkedAlternateVersions(Video video);
 
+        /// <summary>
+        /// Creates or updates a LinkedChild entry linking a parent to a child item.
+        /// </summary>
+        /// <param name="parentId">The parent item ID.</param>
+        /// <param name="childId">The child item ID.</param>
+        /// <param name="childType">The type of linked child relationship.</param>
+        void UpsertLinkedChild(Guid parentId, Guid childId, LinkedChildType childType);
+
         /// <summary>
         /// Adds the parts.
         /// </summary>
diff --git a/MediaBrowser.Controller/Persistence/IItemRepository.cs b/MediaBrowser.Controller/Persistence/IItemRepository.cs
index a063debbb5..c35e8e50a3 100644
--- a/MediaBrowser.Controller/Persistence/IItemRepository.cs
+++ b/MediaBrowser.Controller/Persistence/IItemRepository.cs
@@ -12,6 +12,7 @@ using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Querying;
+using LinkedChildType = MediaBrowser.Controller.Entities.LinkedChildType;
 
 namespace MediaBrowser.Controller.Persistence;
 
@@ -234,4 +235,13 @@ public interface IItemRepository
     /// <param name="toChildId">The child ID to re-route to.</param>
     /// <returns>Number of references updated.</returns>
     int RerouteLinkedChildren(Guid fromChildId, Guid toChildId);
+
+    /// <summary>
+    /// Creates or updates a LinkedChild entry linking a parent to a child item.
+    /// If the link already exists, updates the child type.
+    /// </summary>
+    /// <param name="parentId">The parent item ID.</param>
+    /// <param name="childId">The child item ID.</param>
+    /// <param name="childType">The type of linked child relationship.</param>
+    void UpsertLinkedChild(Guid parentId, Guid childId, LinkedChildType childType);
 }
-- 
cgit v1.2.3


From 268d88a5fb8f0f71c96ba5abcef250d1f7e049ff Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sat, 7 Feb 2026 00:56:55 +0100
Subject: Optimize Collection Grouping, NextUp and Latest queries

---
 Emby.Server.Implementations/Dto/DtoService.cs      |  24 +-
 .../Library/LibraryManager.cs                      |   6 +
 Jellyfin.Api/Controllers/UserLibraryController.cs  |  32 +-
 .../Item/BaseItemRepository.cs                     | 405 ++++++++++++++-------
 MediaBrowser.Controller/Entities/BaseItem.cs       |   4 +-
 MediaBrowser.Controller/Entities/Folder.cs         |  55 +--
 MediaBrowser.Controller/Entities/Movies/BoxSet.cs  |  26 +-
 MediaBrowser.Controller/Library/ILibraryManager.cs |   9 +
 .../Persistence/IItemRepository.cs                 |  10 +
 9 files changed, 361 insertions(+), 210 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index e34e752da3..626f4ed0cd 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -185,10 +185,23 @@ namespace Emby.Server.Implementations.Dto
                 }
             }
 
+            // Batch-fetch played/total counts for all folders to avoid N+1 queries
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null;
+            if (user is not null && options.EnableUserData)
+            {
+                var folderIds = accessibleItems.OfType<Folder>()
+                    .Where(f => f.SupportsUserDataFromChildren && (f.SupportsPlayedStatus || options.ContainsField(ItemFields.RecursiveItemCount)))
+                    .Select(f => f.Id).ToList();
+                if (folderIds.Count > 0)
+                {
+                    playedCountBatch = _libraryManager.GetPlayedAndTotalCountBatch(folderIds, user);
+                }
+            }
+
             for (int index = 0; index < accessibleItems.Count; index++)
             {
                 var item = accessibleItems[index];
-                var dto = GetBaseItemDtoInternal(item, options, user, owner, userDataBatch?.GetValueOrDefault(item.Id), allCollectionFolders, childCountBatch);
+                var dto = GetBaseItemDtoInternal(item, options, user, owner, userDataBatch?.GetValueOrDefault(item.Id), allCollectionFolders, childCountBatch, playedCountBatch);
 
                 if (item is LiveTvChannel tvChannel)
                 {
@@ -240,7 +253,7 @@ namespace Emby.Server.Implementations.Dto
             return dto;
         }
 
-        private BaseItemDto GetBaseItemDtoInternal(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner = null, UserItemData? userData = null, List<Folder>? allCollectionFolders = null, Dictionary<Guid, int>? childCountBatch = null)
+        private BaseItemDto GetBaseItemDtoInternal(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner = null, UserItemData? userData = null, List<Folder>? allCollectionFolders = null, Dictionary<Guid, int>? childCountBatch = null, Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null)
         {
             var dto = new BaseItemDto
             {
@@ -277,7 +290,7 @@ namespace Emby.Server.Implementations.Dto
 
             if (user is not null)
             {
-                AttachUserSpecificInfo(dto, item, user, options, userData, childCountBatch);
+                AttachUserSpecificInfo(dto, item, user, options, userData, childCountBatch, playedCountBatch);
             }
 
             if (item is IHasMediaSources
@@ -485,7 +498,7 @@ namespace Emby.Server.Implementations.Dto
         /// <summary>
         /// Attaches the user specific info.
         /// </summary>
-        private void AttachUserSpecificInfo(BaseItemDto dto, BaseItem item, User user, DtoOptions options, UserItemData? userData = null, Dictionary<Guid, int>? childCountBatch = null)
+        private void AttachUserSpecificInfo(BaseItemDto dto, BaseItem item, User user, DtoOptions options, UserItemData? userData = null, Dictionary<Guid, int>? childCountBatch = null, Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null)
         {
             if (item.IsFolder)
             {
@@ -497,7 +510,8 @@ namespace Emby.Server.Implementations.Dto
                     {
                         // Use pre-fetched user data
                         dto.UserData = GetUserItemDataDto(userData, item.Id);
-                        item.FillUserDataDtoValues(dto.UserData, userData, dto, user, options);
+                        (int Played, int Total)? precomputed = playedCountBatch is not null && playedCountBatch.TryGetValue(item.Id, out var counts) ? counts : null;
+                        item.FillUserDataDtoValues(dto.UserData, userData, dto, user, options, precomputed);
                     }
                     else
                     {
diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 38aec6d491..29eda7d8b1 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -1515,6 +1515,12 @@ namespace Emby.Server.Implementations.Library
             return _itemRepository.GetChildCountBatch(parentIds, userId);
         }
 
+        /// <inheritdoc/>
+        public Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user)
+        {
+            return _itemRepository.GetPlayedAndTotalCountBatch(folderIds, user);
+        }
+
         public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query, List<BaseItem> parents)
         {
             SetTopParentIdsOrAncestors(query, parents);
diff --git a/Jellyfin.Api/Controllers/UserLibraryController.cs b/Jellyfin.Api/Controllers/UserLibraryController.cs
index 3ba7cc3169..c778d3f448 100644
--- a/Jellyfin.Api/Controllers/UserLibraryController.cs
+++ b/Jellyfin.Api/Controllers/UserLibraryController.cs
@@ -564,25 +564,35 @@ public class UserLibraryController : BaseJellyfinApiController
             },
             dtoOptions);
 
-        var dtos = list.Select(i =>
+        var resolvedItems = new BaseItem[list.Count];
+        var childCounts = new int[list.Count];
+        for (int i = 0; i < list.Count; i++)
         {
-            var item = i.Item2[0];
+            var tuple = list[i];
+            var item = tuple.Item2[0];
             var childCount = 0;
 
-            if (i.Item1 is not null && (i.Item2.Count > 1 || i.Item1 is MusicAlbum || i.Item1 is Series ))
+            if (tuple.Item1 is not null && (tuple.Item2.Count > 1 || tuple.Item1 is MusicAlbum || tuple.Item1 is Series))
             {
-                item = i.Item1;
-                childCount = i.Item2.Count;
+                item = tuple.Item1;
+                childCount = tuple.Item2.Count;
             }
 
-            var dto = _dtoService.GetBaseItemDto(item, dtoOptions, user);
-
-            dto.ChildCount = childCount;
+            resolvedItems[i] = item;
+            childCounts[i] = childCount;
+        }
 
-            return dto;
-        });
+        // Fetch DTOs without visibility check since we've already done that in GetLatestItems and restore child counts afterwards
+        var dtos = _dtoService.GetBaseItemDtos(resolvedItems, dtoOptions, user, skipVisibilityCheck: true);
+        for (int i = 0; i < dtos.Count; i++)
+        {
+            if (childCounts[i] > 0)
+            {
+                dtos[i].ChildCount = childCounts[i];
+            }
+        }
 
-        return Ok(dtos);
+        return Ok(dtos.AsEnumerable());
     }
 
     /// <summary>
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index f31fef6a19..20df42583d 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -369,16 +369,10 @@ public sealed class BaseItemRepository
             return GetLatestTvShowItems(context, baseQuery, filter, limit);
         }
 
-        // Determine the grouping key selector based on collection type
-        // Movies: PresentationUniqueKey (groups alternate versions like 4K/1080p)
-        // Music: Album
-        Func<BaseItemEntity, string?> groupKeySelector = collectionType switch
-        {
-            CollectionType.movies => e => e.PresentationUniqueKey,
-            _ => e => e.Album
-        };
-
-        IQueryable<string> topGroupKeys;
+        // Find the top N group keys ordered by most recent DateCreated.
+        // Movies group by PresentationUniqueKey (alternate versions like 4K/1080p share a key).
+        // Music groups by Album.
+        List<string> topGroupKeys;
         if (collectionType is CollectionType.movies)
         {
             topGroupKeys = baseQuery
@@ -387,7 +381,8 @@ public sealed class BaseItemRepository
                 .Select(g => new { GroupKey = g.Key!, MaxDate = g.Max(e => e.DateCreated) })
                 .OrderByDescending(g => g.MaxDate)
                 .Take(limit)
-                .Select(g => g.GroupKey);
+                .Select(g => g.GroupKey)
+                .ToList();
         }
         else
         {
@@ -397,22 +392,39 @@ public sealed class BaseItemRepository
                 .Select(g => new { GroupKey = g.Key!, MaxDate = g.Max(e => e.DateCreated) })
                 .OrderByDescending(g => g.MaxDate)
                 .Take(limit)
-                .Select(g => g.GroupKey);
+                .Select(g => g.GroupKey)
+                .ToList();
         }
 
-        var itemsQuery = collectionType switch
-        {
-            CollectionType.movies => baseQuery.Where(e => e.PresentationUniqueKey != null && topGroupKeys.Contains(e.PresentationUniqueKey)),
-            _ => baseQuery.Where(e => e.Album != null && topGroupKeys.Contains(e.Album))
+        // Get only the first (most recent) item ID per group using a lightweight projection,
+        // then fetch full entities only for those items. This avoids loading all versions/tracks
+        // with expensive navigation properties just to discard duplicates.
+        var allItemsLite = collectionType switch
+        {
+            CollectionType.movies => baseQuery
+                .Where(e => e.PresentationUniqueKey != null && topGroupKeys.Contains(e.PresentationUniqueKey))
+                .OrderByDescending(e => e.DateCreated)
+                .ThenByDescending(e => e.Id)
+                .Select(e => new { e.Id, GroupKey = e.PresentationUniqueKey })
+                .ToList(),
+            _ => baseQuery
+                .Where(e => e.Album != null && topGroupKeys.Contains(e.Album))
+                .OrderByDescending(e => e.DateCreated)
+                .ThenByDescending(e => e.Id)
+                .Select(e => new { e.Id, GroupKey = e.Album })
+                .ToList()
         };
 
-        itemsQuery = itemsQuery.OrderByDescending(e => e.DateCreated).ThenByDescending(e => e.Id);
+        var firstIds = allItemsLite
+            .DistinctBy(e => e.GroupKey)
+            .Select(e => e.Id)
+            .ToList();
+
+        var itemsQuery = context.BaseItems.AsNoTracking().Where(e => firstIds.Contains(e.Id));
         itemsQuery = ApplyNavigations(itemsQuery, filter).AsSingleQuery();
 
         return itemsQuery
             .AsEnumerable()
-            .GroupBy(groupKeySelector)
-            .Select(g => g.First())
             .OrderByDescending(e => e.DateCreated)
             .ThenByDescending(e => e.Id)
             .Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))
@@ -450,35 +462,48 @@ public sealed class BaseItemRepository
         const double RecentAdditionWindowHours = 24.0;
 
         // Step 1: Find the top N series with recently added content, ordered by most recent addition
-        var topSeriesNames = baseQuery
+        var topSeriesWithDates = baseQuery
             .Where(e => e.SeriesName != null)
             .GroupBy(e => e.SeriesName)
             .Select(g => new { SeriesName = g.Key!, MaxDate = g.Max(e => e.DateCreated) })
             .OrderByDescending(g => g.MaxDate)
             .Take(limit)
-            .Select(g => g.SeriesName)
             .ToList();
 
-        // Step 2: Fetch all episodes from the identified series (needed for analysis)
-        var allEpisodes = ApplyNavigations(
-                baseQuery
-                    .Where(e => e.SeriesName != null && topSeriesNames.Contains(e.SeriesName))
-                    .OrderByDescending(e => e.DateCreated)
-                    .ThenByDescending(e => e.Id),
-                filter)
-            .AsSingleQuery()
+        var topSeriesNames = topSeriesWithDates.Select(g => g.SeriesName).ToList();
+
+        // Compute a global date cutoff: the oldest series' max date minus the window.
+        // Episodes before this cutoff cannot be in any series' "recent additions" window,
+        // so we can safely exclude them to avoid loading ancient episodes.
+        var globalCutoff = topSeriesWithDates.Count > 0
+            ? topSeriesWithDates.Min(g => g.MaxDate)?.AddHours(-RecentAdditionWindowHours)
+            : null;
+
+        // Fetch only the columns needed for analysis (lightweight projection).
+        var episodeQuery = baseQuery
+            .Where(e => e.SeriesName != null && topSeriesNames.Contains(e.SeriesName));
+        if (globalCutoff is not null)
+        {
+            episodeQuery = episodeQuery.Where(e => e.DateCreated >= globalCutoff);
+        }
+
+        var allEpisodes = episodeQuery
+            .OrderByDescending(e => e.DateCreated)
+            .ThenByDescending(e => e.Id)
+            .Select(e => new { e.Id, e.SeriesName, e.DateCreated, e.SeasonId, e.SeriesId })
             .ToList();
 
         // Collect all season/series IDs we'll need to look up for count information
         var allSeasonIds = new HashSet<Guid>();
         var allSeriesIds = new HashSet<Guid>();
 
-        // Analysis data for each series: which episodes were recently added and to which seasons
+        // Analysis data for each series: recent episode count, season IDs, and the most recent episode ID
         var analysisData = new List<(
-            List<BaseItemEntity> RecentEpisodes,
+            int RecentEpisodeCount,
             List<Guid> SeasonIds,
+            Guid? FirstRecentSeriesId,
             DateTime MaxDate,
-            BaseItemEntity MostRecentEpisode)>();
+            Guid MostRecentEpisodeId)>();
 
         // Step 3: Analyze each series to identify recent additions within the time window
         foreach (var group in allEpisodes.GroupBy(e => e.SeriesName))
@@ -488,23 +513,26 @@ public sealed class BaseItemRepository
             var recentCutoff = mostRecentDate.AddHours(-RecentAdditionWindowHours);
 
             // Find episodes added within the recent window
-            var recentEpisodes = new List<BaseItemEntity>();
+            var recentEpisodeCount = 0;
             var seasonIdSet = new HashSet<Guid>();
+            Guid? firstRecentSeriesId = null;
 
             foreach (var ep in episodes)
             {
                 if (ep.DateCreated >= recentCutoff)
                 {
-                    recentEpisodes.Add(ep);
+                    recentEpisodeCount++;
                     if (ep.SeasonId.HasValue)
                     {
                         seasonIdSet.Add(ep.SeasonId.Value);
                     }
+
+                    firstRecentSeriesId ??= ep.SeriesId;
                 }
             }
 
             var seasonIds = seasonIdSet.ToList();
-            analysisData.Add((recentEpisodes, seasonIds, mostRecentDate, episodes[0]));
+            analysisData.Add((recentEpisodeCount, seasonIds, firstRecentSeriesId, mostRecentDate, episodes[0].Id));
 
             // Track all unique season/series IDs for batch lookups
             foreach (var sid in seasonIds)
@@ -512,9 +540,9 @@ public sealed class BaseItemRepository
                 allSeasonIds.Add(sid);
             }
 
-            if (recentEpisodes.Count > 0 && recentEpisodes[0].SeriesId.HasValue)
+            if (firstRecentSeriesId.HasValue)
             {
-                allSeriesIds.Add(recentEpisodes[0].SeriesId!.Value);
+                allSeriesIds.Add(firstRecentSeriesId.Value);
             }
         }
 
@@ -542,9 +570,9 @@ public sealed class BaseItemRepository
 
         // Step 5: Apply the container selection logic for each series
         var entitiesToFetch = new HashSet<Guid>();
-        var seriesResults = new List<(Guid? SeasonId, Guid? SeriesId, DateTime MaxDate, BaseItemEntity MostRecentEpisode)>(analysisData.Count);
+        var seriesResults = new List<(Guid? SeasonId, Guid? SeriesId, DateTime MaxDate, Guid MostRecentEpisodeId)>(analysisData.Count);
 
-        foreach (var (recentEpisodes, seasonIds, maxDate, mostRecentEpisode) in analysisData)
+        foreach (var (recentEpisodeCount, seasonIds, firstRecentSeriesId, maxDate, mostRecentEpisodeId) in analysisData)
         {
             Guid? seasonId = null;
             Guid? seriesId = null;
@@ -554,13 +582,12 @@ public sealed class BaseItemRepository
                 // All recent episodes are from a single season
                 var sid = seasonIds[0];
                 var totalEpisodes = seasonEpisodeCounts.GetValueOrDefault(sid, 0);
-                var episodeSeriesId = recentEpisodes.Count > 0 ? recentEpisodes[0].SeriesId : null;
-                var totalSeasonsInSeries = episodeSeriesId.HasValue
-                    ? seriesSeasonCounts.GetValueOrDefault(episodeSeriesId.Value, 1)
+                var totalSeasonsInSeries = firstRecentSeriesId.HasValue
+                    ? seriesSeasonCounts.GetValueOrDefault(firstRecentSeriesId.Value, 1)
                     : 1;
 
                 // Check if multiple episodes were added, or if all episodes in the season were added
-                var hasMultipleOrAllEpisodes = recentEpisodes.Count > 1 || recentEpisodes.Count == totalEpisodes;
+                var hasMultipleOrAllEpisodes = recentEpisodeCount > 1 || recentEpisodeCount == totalEpisodes;
 
                 if (totalSeasonsInSeries > 1 && hasMultipleOrAllEpisodes)
                 {
@@ -568,23 +595,28 @@ public sealed class BaseItemRepository
                     seasonId = sid;
                     entitiesToFetch.Add(sid);
                 }
-                else if (hasMultipleOrAllEpisodes && episodeSeriesId.HasValue)
+                else if (hasMultipleOrAllEpisodes && firstRecentSeriesId.HasValue)
                 {
                     // Single-season series with bulk additions: show the Series
-                    seriesId = episodeSeriesId;
-                    entitiesToFetch.Add(episodeSeriesId.Value);
+                    seriesId = firstRecentSeriesId;
+                    entitiesToFetch.Add(firstRecentSeriesId.Value);
                 }
 
                 // Otherwise: single episode, will fall through to show the Episode
             }
-            else if (seasonIds.Count > 1 && recentEpisodes.Count > 0 && recentEpisodes[0].SeriesId.HasValue)
+            else if (seasonIds.Count > 1 && firstRecentSeriesId.HasValue)
             {
                 // Recent episodes span multiple seasons: show the Series
-                seriesId = recentEpisodes[0].SeriesId;
+                seriesId = firstRecentSeriesId;
                 entitiesToFetch.Add(seriesId!.Value);
             }
 
-            seriesResults.Add((seasonId, seriesId, maxDate, mostRecentEpisode));
+            if (seasonId is null && seriesId is null)
+            {
+                entitiesToFetch.Add(mostRecentEpisodeId);
+            }
+
+            seriesResults.Add((seasonId, seriesId, maxDate, mostRecentEpisodeId));
         }
 
         // Step 6: Fetch the Season/Series entities we decided to return
@@ -596,9 +628,10 @@ public sealed class BaseItemRepository
                 .ToDictionary(e => e.Id)
             : [];
 
-        // Step 7: Build final results, preferring Season > Series > Episode
+        // Step 7: Build final results, preferring Season > Series > Episode.
+        // All needed entities are already fetched in step 6 with navigation properties.
         var results = new List<(BaseItemEntity Entity, DateTime MaxDate)>(seriesResults.Count);
-        foreach (var (seasonId, seriesId, maxDate, mostRecentEpisode) in seriesResults)
+        foreach (var (seasonId, seriesId, maxDate, mostRecentEpisodeId) in seriesResults)
         {
             if (seasonId.HasValue && entities.TryGetValue(seasonId.Value, out var seasonEntity))
             {
@@ -612,8 +645,10 @@ public sealed class BaseItemRepository
                 continue;
             }
 
-            // Fallback: show the most recent episode
-            results.Add((mostRecentEpisode, maxDate));
+            if (entities.TryGetValue(mostRecentEpisodeId, out var episodeEntity))
+            {
+                results.Add((episodeEntity, maxDate));
+            }
         }
 
         return results
@@ -733,94 +768,73 @@ public sealed class BaseItemRepository
         Dictionary<string, List<BaseItemEntity>> specialsBySeriesKey = new();
         if (includeSpecials)
         {
-            var allSpecials = context.BaseItems
+            var specialsQuery = context.BaseItems
                 .AsNoTracking()
                 .Where(e => e.Type == episodeTypeName)
                 .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
                 .Where(e => e.ParentIndexNumber == 0)
-                .Where(e => !e.IsVirtualItem)
-                .ToList();
+                .Where(e => !e.IsVirtualItem);
+            specialsQuery = ApplyNavigations(specialsQuery, filter).AsSingleQuery();
 
-            var specialIds = allSpecials.Select(s => s.Id).ToList();
-            if (specialIds.Count > 0)
+            foreach (var special in specialsQuery)
             {
-                var specialsWithNav = context.BaseItems.AsNoTracking().Where(e => specialIds.Contains(e.Id));
-                specialsWithNav = ApplyNavigations(specialsWithNav, filter).AsSingleQuery();
-                var specialsDict = specialsWithNav.ToDictionary(e => e.Id);
-
-                foreach (var special in allSpecials)
+                var key = special.SeriesPresentationUniqueKey!;
+                if (!specialsBySeriesKey.TryGetValue(key, out var list))
                 {
-                    var key = special.SeriesPresentationUniqueKey!;
-                    if (!specialsBySeriesKey.TryGetValue(key, out var list))
-                    {
-                        list = new List<BaseItemEntity>();
-                        specialsBySeriesKey[key] = list;
-                    }
-
-                    if (specialsDict.TryGetValue(special.Id, out var specialWithNav))
-                    {
-                        list.Add(specialWithNav);
-                    }
+                    list = new List<BaseItemEntity>();
+                    specialsBySeriesKey[key] = list;
                 }
+
+                list.Add(special);
             }
         }
 
-        var nextEpisodeIds = new HashSet<Guid>();
-        var seriesNextIdMap = new Dictionary<string, Guid>();
-        var seriesNextPlayedIdMap = new Dictionary<string, Guid>();
-        var allCandidatesWithPlayedStatus = context.BaseItems
+        // Build position lookup from already-loaded last watched data
+        var positionLookup = new Dictionary<string, (int Season, int Episode)>();
+        foreach (var kvp in lastWatchedInfo)
+        {
+            if (kvp.Value != Guid.Empty
+                && lastWatchedEpisodes.TryGetValue(kvp.Value, out var lw)
+                && lw.ParentIndexNumber.HasValue
+                && lw.IndexNumber.HasValue)
+            {
+                positionLookup[kvp.Key] = (lw.ParentIndexNumber.Value, lw.IndexNumber.Value);
+            }
+        }
+
+        // Single query: fetch all unplayed non-virtual non-special episodes for all series.
+        // Uses NOT EXISTS (via !Any) for the played check, which is more efficient than GroupJoin.
+        // Only unplayed episodes are loaded (typically ~10% of total), keeping memory usage low.
+        var allUnplayedCandidates = context.BaseItems
             .AsNoTracking()
             .Where(e => e.Type == episodeTypeName)
             .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
             .Where(e => e.ParentIndexNumber != 0)
             .Where(e => !e.IsVirtualItem)
-            .GroupJoin(
-                context.UserData.AsNoTracking().Where(ud => ud.UserId == userId),
-                e => e.Id,
-                ud => ud.ItemId,
-                (episode, userData) => new
-                {
-                    episode.Id,
-                    episode.SeriesPresentationUniqueKey,
-                    episode.ParentIndexNumber,
-                    EpisodeNumber = episode.IndexNumber,
-                    IsPlayed = userData.Any(ud => ud.Played)
-                })
-            .ToList();
-
-        // For regular NextUp: unplayed episodes
-        var allNextUpCandidates = allCandidatesWithPlayedStatus
-            .Where(c => !c.IsPlayed)
-            .Select(c => new { c.Id, c.SeriesPresentationUniqueKey, c.ParentIndexNumber, c.EpisodeNumber })
+            .Where(e => !e.UserData!.Any(ud => ud.UserId == userId && ud.Played))
+            .Select(e => new
+            {
+                e.Id,
+                e.SeriesPresentationUniqueKey,
+                e.ParentIndexNumber,
+                EpisodeNumber = e.IndexNumber
+            })
             .ToList();
 
-        // For rewatching: played episodes (only used when includeWatchedForRewatching is true)
-        var allNextPlayedCandidates = includeWatchedForRewatching
-            ? allCandidatesWithPlayedStatus
-                .Where(c => c.IsPlayed)
-                .Select(c => new { c.Id, c.SeriesPresentationUniqueKey, c.ParentIndexNumber, c.EpisodeNumber })
-                .ToList()
-            : [];
+        // In-memory: find the next unplayed episode per series, respecting last-watched position
+        var nextEpisodeIds = new HashSet<Guid>();
+        var seriesNextIdMap = new Dictionary<string, Guid>();
 
         foreach (var seriesKey in seriesKeys)
         {
-            var candidates = allNextUpCandidates
+            var candidates = allUnplayedCandidates
                 .Where(c => c.SeriesPresentationUniqueKey == seriesKey);
 
-            if (lastWatchedInfo.TryGetValue(seriesKey, out var lwId) && lwId != Guid.Empty)
+            if (positionLookup.TryGetValue(seriesKey, out var pos))
             {
-                var lastWatchedEntity = lastWatchedEpisodes.GetValueOrDefault(lwId);
-                if (lastWatchedEntity is not null)
-                {
-                    var season = lastWatchedEntity.ParentIndexNumber;
-                    var episode = lastWatchedEntity.IndexNumber;
-                    if (season.HasValue && episode.HasValue)
-                    {
-                        candidates = candidates.Where(c =>
-                            c.ParentIndexNumber > season ||
-                            (c.ParentIndexNumber == season && c.EpisodeNumber > episode));
-                    }
-                }
+                candidates = candidates.Where(c =>
+                    c.ParentIndexNumber > pos.Season
+                    || (c.ParentIndexNumber == pos.Season && c.EpisodeNumber > pos.Episode));
             }
 
             var nextCandidate = candidates
@@ -833,39 +847,67 @@ public sealed class BaseItemRepository
                 nextEpisodeIds.Add(nextCandidate.Id);
                 seriesNextIdMap[seriesKey] = nextCandidate.Id;
             }
+        }
 
-            if (includeWatchedForRewatching && lastWatchedByDateInfo.TryGetValue(seriesKey, out var lastByDateId))
+        // Find next played episode per series for rewatching mode
+        var seriesNextPlayedIdMap = new Dictionary<string, Guid>();
+        if (includeWatchedForRewatching)
+        {
+            var allPlayedCandidates = context.BaseItems
+                .AsNoTracking()
+                .Where(e => e.Type == episodeTypeName)
+                .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
+                .Where(e => e.ParentIndexNumber != 0)
+                .Where(e => !e.IsVirtualItem)
+                .Where(e => e.UserData!.Any(ud => ud.UserId == userId && ud.Played))
+                .Select(e => new
+                {
+                    e.Id,
+                    e.SeriesPresentationUniqueKey,
+                    e.ParentIndexNumber,
+                    EpisodeNumber = e.IndexNumber
+                })
+                .ToList();
+
+            foreach (var seriesKey in seriesKeys)
             {
+                if (!lastWatchedByDateInfo.TryGetValue(seriesKey, out var lastByDateId))
+                {
+                    continue;
+                }
+
                 var lastByDateEntity = lastWatchedEpisodes.GetValueOrDefault(lastByDateId);
-                if (lastByDateEntity is not null)
+                if (lastByDateEntity is null)
                 {
-                    var lastSeason = lastByDateEntity.ParentIndexNumber;
-                    var lastEp = lastByDateEntity.IndexNumber;
+                    continue;
+                }
 
-                    var playedCandidates = allNextPlayedCandidates
-                        .Where(c => c.SeriesPresentationUniqueKey == seriesKey);
+                var playedCandidates = allPlayedCandidates
+                    .Where(c => c.SeriesPresentationUniqueKey == seriesKey);
 
-                    if (lastSeason.HasValue && lastEp.HasValue)
-                    {
-                        playedCandidates = playedCandidates.Where(c =>
-                            c.ParentIndexNumber > lastSeason ||
-                            (c.ParentIndexNumber == lastSeason && c.EpisodeNumber > lastEp));
-                    }
+                if (lastByDateEntity.ParentIndexNumber.HasValue && lastByDateEntity.IndexNumber.HasValue)
+                {
+                    var lastSeason = lastByDateEntity.ParentIndexNumber.Value;
+                    var lastEp = lastByDateEntity.IndexNumber.Value;
+                    playedCandidates = playedCandidates.Where(c =>
+                        c.ParentIndexNumber > lastSeason
+                        || (c.ParentIndexNumber == lastSeason && c.EpisodeNumber > lastEp));
+                }
 
-                    var nextPlayedCandidate = playedCandidates
-                        .OrderBy(c => c.ParentIndexNumber)
-                        .ThenBy(c => c.EpisodeNumber)
-                        .FirstOrDefault();
+                var nextPlayedCandidate = playedCandidates
+                    .OrderBy(c => c.ParentIndexNumber)
+                    .ThenBy(c => c.EpisodeNumber)
+                    .FirstOrDefault();
 
-                    if (nextPlayedCandidate is not null && nextPlayedCandidate.Id != Guid.Empty)
-                    {
-                        nextEpisodeIds.Add(nextPlayedCandidate.Id);
-                        seriesNextPlayedIdMap[seriesKey] = nextPlayedCandidate.Id;
-                    }
+                if (nextPlayedCandidate is not null && nextPlayedCandidate.Id != Guid.Empty)
+                {
+                    nextEpisodeIds.Add(nextPlayedCandidate.Id);
+                    seriesNextPlayedIdMap[seriesKey] = nextPlayedCandidate.Id;
                 }
             }
         }
 
+        // Batch fetch all next episode entities with navigation properties
         var nextEpisodes = new Dictionary<Guid, BaseItemEntity>();
         if (nextEpisodeIds.Count > 0)
         {
@@ -950,11 +992,47 @@ public sealed class BaseItemRepository
             dbQuery = dbQuery.Distinct();
         }
 
+        if (filter.CollapseBoxSetItems == true)
+        {
+            dbQuery = ApplyBoxSetCollapsing(context, dbQuery);
+        }
+
         dbQuery = ApplyOrder(dbQuery, filter, context);
 
         return dbQuery;
     }
 
+    private IQueryable<BaseItemEntity> ApplyBoxSetCollapsing(
+        JellyfinDbContext context,
+        IQueryable<BaseItemEntity> dbQuery)
+    {
+        var boxSetTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.BoxSet];
+
+        var currentIds = dbQuery.Select(e => e.Id);
+
+        // Items that are NOT box sets and NOT in any box set
+        var notInBoxSet = currentIds
+            .Where(id =>
+                !context.BaseItems.Any(bs => bs.Id == id && bs.Type == boxSetTypeName)
+                && !context.LinkedChildren.Any(lc =>
+                    lc.ChildId == id
+                    && lc.ChildType == DbLinkedChildType.Manual
+                    && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName)));
+
+        // Box set IDs containing at least one accessible child item.
+        // Access filtering is already applied to currentIds via TranslateQuery
+        var boxSetIds = context.LinkedChildren
+            .Where(lc =>
+                lc.ChildType == DbLinkedChildType.Manual
+                && currentIds.Contains(lc.ChildId)
+                && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName))
+            .Select(lc => lc.ParentId)
+            .Distinct();
+
+        var collapsedIds = notInBoxSet.Union(boxSetIds);
+        return context.BaseItems.Where(e => collapsedIds.Contains(e.Id));
+    }
+
     private static IQueryable<BaseItemEntity> ApplyNavigations(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
     {
         if (filter.TrailerTypes.Length > 0 || filter.IncludeItemTypes.Contains(BaseItemKind.Trailer))
@@ -1002,7 +1080,7 @@ public sealed class BaseItemRepository
             dbQuery = dbQuery.Include(e => e.Extras);
         }
 
-        return dbQuery.AsSingleQuery();
+        return dbQuery;
     }
 
     private IQueryable<BaseItemEntity> ApplyQueryPaging(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
@@ -1709,8 +1787,7 @@ public sealed class BaseItemRepository
             .Include(e => e.LockedFields)
             .Include(e => e.UserData)
             .Include(e => e.Images)
-            .Include(e => e.LinkedChildEntities)
-            .AsSingleQuery();
+            .Include(e => e.LinkedChildEntities);
 
         var item = dbQuery.FirstOrDefault(e => e.Id == id);
         if (item is null)
@@ -3745,6 +3822,52 @@ public sealed class BaseItemRepository
         return GetPlayedAndTotalCountFromQuery(baseQuery, filter.User.Id);
     }
 
+    /// <inheritdoc/>
+    public Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user)
+    {
+        ArgumentNullException.ThrowIfNull(folderIds);
+        ArgumentNullException.ThrowIfNull(user);
+
+        if (folderIds.Count == 0)
+        {
+            return new Dictionary<Guid, (int Played, int Total)>();
+        }
+
+        using var dbContext = _dbProvider.CreateDbContext();
+        var folderIdsArray = folderIds.ToArray();
+
+        // Build access filter from user preferences (parental ratings, blocked/allowed tags, etc.)
+        var filter = new InternalItemsQuery(user);
+
+        // Get all non-folder, non-virtual descendants via AncestorIds table
+        var baseQuery = dbContext.BaseItems
+            .Where(b => dbContext.AncestorIds
+                .Any(a => folderIdsArray.Contains(a.ParentItemId) && a.ItemId == b.Id))
+            .Where(b => !b.IsFolder && !b.IsVirtualItem);
+
+        // Apply the same access filtering as per-item path
+        baseQuery = ApplyAccessFiltering(dbContext, baseQuery, filter);
+
+        // Join back with AncestorIds to group by parent folder ID and compute counts
+        var results = dbContext.AncestorIds
+            .Where(a => folderIdsArray.Contains(a.ParentItemId))
+            .Join(
+                baseQuery,
+                a => a.ItemId,
+                b => b.Id,
+                (a, b) => new { a.ParentItemId, b.Id, b.UserData })
+            .GroupBy(x => x.ParentItemId)
+            .Select(g => new
+            {
+                FolderId = g.Key,
+                Total = g.Count(),
+                Played = g.Count(x => x.UserData!.Any(ud => ud.UserId == user.Id && ud.Played))
+            })
+            .ToDictionary(x => x.FolderId, x => (x.Played, x.Total));
+
+        return results;
+    }
+
     /// <inheritdoc/>
     public IReadOnlyList<Guid> GetLinkedChildrenIds(Guid parentId, int? childType = null)
     {
diff --git a/MediaBrowser.Controller/Entities/BaseItem.cs b/MediaBrowser.Controller/Entities/BaseItem.cs
index d366e0288a..67b56ba5f0 100644
--- a/MediaBrowser.Controller/Entities/BaseItem.cs
+++ b/MediaBrowser.Controller/Entities/BaseItem.cs
@@ -1693,7 +1693,7 @@ namespace MediaBrowser.Controller.Entities
             return list.Distinct(StringComparer.OrdinalIgnoreCase).ToList();
         }
 
-        private bool IsVisibleViaTags(User user, bool skipAllowedTagsCheck)
+        protected bool IsVisibleViaTags(User user, bool skipAllowedTagsCheck)
         {
             var blockedTags = user.GetPreference(PreferenceKind.BlockedTags);
             var allowedTags = user.GetPreference(PreferenceKind.AllowedTags);
@@ -2487,7 +2487,7 @@ namespace MediaBrowser.Controller.Entities
             return path;
         }
 
-        public virtual void FillUserDataDtoValues(UserItemDataDto dto, UserItemData userData, BaseItemDto itemDto, User user, DtoOptions fields)
+        public virtual void FillUserDataDtoValues(UserItemDataDto dto, UserItemData userData, BaseItemDto itemDto, User user, DtoOptions fields, (int Played, int Total)? precomputedCounts = null)
         {
             if (RunTimeTicks.HasValue)
             {
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index e1f7d095c3..44903fd4c1 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -730,36 +730,9 @@ namespace MediaBrowser.Controller.Entities
 
         public QueryResult<BaseItem> QueryRecursive(InternalItemsQuery query)
         {
-            var user = query.User;
-
             if (!query.ForceDirect && RequiresPostFiltering(query))
             {
-                IEnumerable<BaseItem> items;
-                Func<BaseItem, bool> filter = i => UserViewBuilder.Filter(i, user, query, UserDataManager, LibraryManager);
-
-                var totalCount = 0;
-                if (query.User is null)
-                {
-                    items = GetRecursiveChildren(filter);
-                    totalCount = items.Count();
-                }
-                else
-                {
-                    // Save pagination params before clearing them to prevent pagination from happening
-                    // before sorting. PostFilterAndSort will apply pagination after sorting.
-                    var limit = query.Limit;
-                    var startIndex = query.StartIndex;
-                    query.Limit = null;
-                    query.StartIndex = null;
-
-                    items = GetRecursiveChildren(user, query, out totalCount);
-
-                    // Restore pagination params so PostFilterAndSort can apply them after sorting
-                    query.Limit = limit;
-                    query.StartIndex = startIndex;
-                }
-
-                return PostFilterAndSort(items, query);
+                query.CollapseBoxSetItems = true;
             }
 
             if (this is not UserRootFolder
@@ -1690,7 +1663,7 @@ namespace MediaBrowser.Controller.Entities
             return !IsPlayed(user, userItemData);
         }
 
-        public override void FillUserDataDtoValues(UserItemDataDto dto, UserItemData userData, BaseItemDto itemDto, User user, DtoOptions fields)
+        public override void FillUserDataDtoValues(UserItemDataDto dto, UserItemData userData, BaseItemDto itemDto, User user, DtoOptions fields, (int Played, int Total)? precomputedCounts = null)
         {
             if (!SupportsUserDataFromChildren)
             {
@@ -1699,22 +1672,28 @@ namespace MediaBrowser.Controller.Entities
 
             if (SupportsPlayedStatus || (itemDto is not null && fields.ContainsField(ItemFields.RecursiveItemCount)))
             {
-                // Create a minimal query with just the user - skip ConfigureUserAccess to avoid
-                // expensive GetUserViews calls. Since we're counting descendants of a specific
-                // item (this folder) that the user already has access to, TopParentIds filtering
-                // is redundant. The parental rating filter is applied via query.User.
-                var query = new InternalItemsQuery(user);
-
                 int playedCount;
                 int totalCount;
 
-                if (LinkedChildren.Length > 0)
+                if (precomputedCounts.HasValue && LinkedChildren.Length == 0)
                 {
-                    (playedCount, totalCount) = ItemRepository.GetPlayedAndTotalCountFromLinkedChildren(query, Id);
+                    // Use batch-fetched counts (avoids N+1 queries)
+                    (playedCount, totalCount) = precomputedCounts.Value;
                 }
                 else
                 {
-                    (playedCount, totalCount) = ItemRepository.GetPlayedAndTotalCount(query, Id);
+                    // Fall back to per-item query for LinkedChildren items (BoxSets, Playlists)
+                    // or when no batch data is available
+                    var query = new InternalItemsQuery(user);
+
+                    if (LinkedChildren.Length > 0)
+                    {
+                        (playedCount, totalCount) = ItemRepository.GetPlayedAndTotalCountFromLinkedChildren(query, Id);
+                    }
+                    else
+                    {
+                        (playedCount, totalCount) = ItemRepository.GetPlayedAndTotalCount(query, Id);
+                    }
                 }
 
                 if (itemDto is not null && fields.ContainsField(ItemFields.RecursiveItemCount))
diff --git a/MediaBrowser.Controller/Entities/Movies/BoxSet.cs b/MediaBrowser.Controller/Entities/Movies/BoxSet.cs
index c55a70a67b..c6579285db 100644
--- a/MediaBrowser.Controller/Entities/Movies/BoxSet.cs
+++ b/MediaBrowser.Controller/Entities/Movies/BoxSet.cs
@@ -158,25 +158,25 @@ namespace MediaBrowser.Controller.Entities.Movies
                 return base.IsVisible(user, skipAllowedTagsCheck);
             }
 
-            if (base.IsVisible(user, skipAllowedTagsCheck))
+            if (!IsVisibleViaTags(user, skipAllowedTagsCheck))
             {
-                if (LinkedChildren.Length == 0)
-                {
-                    return true;
-                }
+                return false;
+            }
 
-                var userLibraryFolderIds = GetLibraryFolderIds(user);
-                var libraryFolderIds = LibraryFolderIds ?? GetLibraryFolderIds();
+            if (LinkedChildren.Length == 0)
+            {
+                return true;
+            }
 
-                if (libraryFolderIds.Length == 0)
-                {
-                    return true;
-                }
+            var userLibraryFolderIds = GetLibraryFolderIds(user);
+            var libraryFolderIds = LibraryFolderIds ?? GetLibraryFolderIds();
 
-                return userLibraryFolderIds.Any(i => libraryFolderIds.Contains(i));
+            if (libraryFolderIds.Length == 0)
+            {
+                return true;
             }
 
-            return false;
+            return userLibraryFolderIds.Any(i => libraryFolderIds.Contains(i));
         }
 
         public override bool IsVisibleStandalone(User user)
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index 9b46dec3fe..3b3295c57d 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -697,6 +697,15 @@ namespace MediaBrowser.Controller.Library
         /// <returns>Dictionary mapping parent ID to child count.</returns>
         Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId);
 
+        /// <summary>
+        /// Batch-fetches played and total counts for multiple folder items.
+        /// Avoids N+1 queries when building DTOs for lists of folder items.
+        /// </summary>
+        /// <param name="folderIds">The list of folder item IDs.</param>
+        /// <param name="user">The user for access filtering and played status.</param>
+        /// <returns>Dictionary mapping folder ID to (Played count, Total count).</returns>
+        Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user);
+
         /// <summary>
         /// Configures the query with user access settings including TopParentIds for library access.
         /// Call this before passing a query to methods that need user access filtering.
diff --git a/MediaBrowser.Controller/Persistence/IItemRepository.cs b/MediaBrowser.Controller/Persistence/IItemRepository.cs
index c35e8e50a3..f1b27c52db 100644
--- a/MediaBrowser.Controller/Persistence/IItemRepository.cs
+++ b/MediaBrowser.Controller/Persistence/IItemRepository.cs
@@ -188,6 +188,16 @@ public interface IItemRepository
     /// <returns>A tuple containing (Played count, Total count).</returns>
     (int Played, int Total) GetPlayedAndTotalCountFromLinkedChildren(InternalItemsQuery filter, Guid parentId);
 
+    /// <summary>
+    /// Batch-fetches played and total counts for multiple folder items using the AncestorIds table.
+    /// This avoids N+1 queries when building DTOs for lists of folder items (Series, Seasons, etc.).
+    /// Applies user access filtering (parental controls, tags).
+    /// </summary>
+    /// <param name="folderIds">The list of folder item IDs to get counts for.</param>
+    /// <param name="user">The user for access filtering and played status.</param>
+    /// <returns>Dictionary mapping folder ID to (Played count, Total count).</returns>
+    Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user);
+
     /// <summary>
     /// Gets the IDs of linked children for the specified parent.
     /// </summary>
-- 
cgit v1.2.3


From 2420ece5fe47c3d990641add1648b9c220215a62 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sat, 7 Feb 2026 19:01:37 +0100
Subject: Fix version resolution and scan handling

---
 .../Library/LibraryManager.cs                      | 29 +++++++++++---
 .../Migrations/Routines/MigrateLinkedChildren.cs   | 44 ++++++++++++----------
 MediaBrowser.Controller/Entities/Movies/Movie.cs   |  9 ++++-
 MediaBrowser.Controller/Entities/Video.cs          | 37 +++++++++++++-----
 MediaBrowser.Controller/Library/ILibraryManager.cs |  4 +-
 .../SqliteDatabaseProvider.cs                      |  3 +-
 6 files changed, 90 insertions(+), 36 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 29eda7d8b1..6bb5f87d03 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -407,7 +407,8 @@ namespace Emby.Server.Implementations.Library
             }
 
             // If deleting a primary version video, clear PrimaryVersionId from alternate versions
-            if (item is Video video && string.IsNullOrEmpty(video.PrimaryVersionId))
+            // OwnerId check: items with OwnerId set are alternate versions or extras, not primaries
+            if (item is Video video && string.IsNullOrEmpty(video.PrimaryVersionId) && video.OwnerId.IsEmpty())
             {
                 var alternateVersions = GetLocalAlternateVersionIds(video)
                     .Concat(GetLinkedAlternateVersions(video).Select(v => v.Id))
@@ -700,8 +701,8 @@ namespace Emby.Server.Implementations.Library
             return key.GetMD5();
         }
 
-        public BaseItem? ResolvePath(FileSystemMetadata fileInfo, Folder? parent = null, IDirectoryService? directoryService = null)
-            => ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent);
+        public BaseItem? ResolvePath(FileSystemMetadata fileInfo, Folder? parent = null, IDirectoryService? directoryService = null, CollectionType? collectionType = null)
+            => ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent, collectionType);
 
         private BaseItem? ResolvePath(
             FileSystemMetadata fileInfo,
@@ -2105,6 +2106,8 @@ namespace Emby.Server.Implementations.Library
             // Resolve and add any local alternate version items that don't exist yet
             // This ensures they exist in the database when LinkedChildren are processed
             var allItems = new List<BaseItem>(items);
+            var parentFolder = parent as Folder;
+            var parentCollectionType = parent is not null ? GetTopFolderContentType(parent) : null;
             foreach (var item in items)
             {
                 if (item is Video video && video.LocalAlternateVersions.Length > 0)
@@ -2122,7 +2125,14 @@ namespace Emby.Server.Implementations.Library
                         if (GetItemById(altId) is null && !allItems.Any(i => i.Id.Equals(altId)))
                         {
                             // Alternate version doesn't exist, resolve and create it
-                            var altVideo = ResolvePath(_fileSystem.GetFileSystemInfo(path)) as Video;
+                            // Pass parent and collectionType so the resolver creates the correct type
+                            // (e.g. Movie instead of generic Video)
+                            var altVideo = ResolvePath(
+                                _fileSystem.GetFileSystemInfo(path),
+                                new DirectoryService(_fileSystem),
+                                null,
+                                parentFolder,
+                                parentCollectionType) as Video;
                             if (altVideo is not null)
                             {
                                 altVideo.OwnerId = video.Id;
@@ -2304,6 +2314,8 @@ namespace Emby.Server.Implementations.Library
             // Resolve and add any local alternate version items that don't exist yet
             // This ensures they exist in the database when LinkedChildren are processed
             var allItems = new List<BaseItem>(items);
+            var parentFolder = parent as Folder;
+            var parentCollectionType = GetTopFolderContentType(parent);
             foreach (var item in items)
             {
                 if (item is Video video && video.LocalAlternateVersions.Length > 0)
@@ -2321,7 +2333,14 @@ namespace Emby.Server.Implementations.Library
                         if (GetItemById(altId) is null && !allItems.Any(i => i.Id.Equals(altId)))
                         {
                             // Alternate version doesn't exist, resolve and create it
-                            var altVideo = ResolvePath(_fileSystem.GetFileSystemInfo(path)) as Video;
+                            // Pass parent and collectionType so the resolver creates the correct type
+                            // (e.g. Movie instead of generic Video)
+                            var altVideo = ResolvePath(
+                                _fileSystem.GetFileSystemInfo(path),
+                                new DirectoryService(_fileSystem),
+                                null,
+                                parentFolder,
+                                parentCollectionType) as Video;
                             if (altVideo is not null)
                             {
                                 altVideo.OwnerId = video.Id;
diff --git a/Jellyfin.Server/Migrations/Routines/MigrateLinkedChildren.cs b/Jellyfin.Server/Migrations/Routines/MigrateLinkedChildren.cs
index d08d1a4efd..9dfb8be900 100644
--- a/Jellyfin.Server/Migrations/Routines/MigrateLinkedChildren.cs
+++ b/Jellyfin.Server/Migrations/Routines/MigrateLinkedChildren.cs
@@ -5,6 +5,7 @@ using System.Text.Json;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
 using Jellyfin.Extensions;
+using MediaBrowser.Controller.Library;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using LinkedChildType = Jellyfin.Database.Implementations.Entities.LinkedChildType;
@@ -20,13 +21,16 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
 {
     private readonly ILogger<MigrateLinkedChildren> _logger;
     private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly ILibraryManager _libraryManager;
 
     public MigrateLinkedChildren(
         ILoggerFactory loggerFactory,
-        IDbContextFactory<JellyfinDbContext> dbProvider)
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        ILibraryManager libraryManager)
     {
         _logger = loggerFactory.CreateLogger<MigrateLinkedChildren>();
         _dbProvider = dbProvider;
+        _libraryManager = libraryManager;
     }
 
     /// <inheritdoc/>
@@ -219,19 +223,21 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
 
         _logger.LogInformation("LinkedChildren migration completed. Processed {Count} items.", processedCount);
 
-        UpdateAlternateVersionTypes(context);
+        CleanupWrongTypeAlternateVersions(context);
         CleanupOrphanedLinkedChildren(context);
     }
 
-    private void UpdateAlternateVersionTypes(JellyfinDbContext context)
+    private void CleanupWrongTypeAlternateVersions(JellyfinDbContext context)
     {
-        _logger.LogInformation("Updating alternate version item types to match their parent's type...");
+        _logger.LogInformation("Cleaning up alternate version items with wrong type...");
 
         // Find all LocalAlternateVersion relationships where the child is a generic Video
-        // but the parent is a more specific type (like Movie)
+        // but the parent is a more specific type (like Movie).
+        // Since IDs are computed from type + path, just updating the Type column would break ID lookups.
+        // Instead, delete them and let the runtime recreate them with the correct type during the next library scan.
         var genericVideoType = "MediaBrowser.Controller.Entities.Video";
 
-        var alternateVersionsToUpdate = context.LinkedChildren
+        var wrongTypeChildIds = context.LinkedChildren
             .Where(lc => lc.ChildType == LinkedChildType.LocalAlternateVersion)
             .Join(
                 context.BaseItems,
@@ -242,30 +248,30 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
                 context.BaseItems,
                 x => x.ChildId,
                 child => child.Id,
-                (x, child) => new { x.ChildId, x.ParentType, ChildType = child.Type, Child = child })
+                (x, child) => new { x.ChildId, x.ParentType, ChildType = child.Type })
             .Where(x => x.ChildType == genericVideoType && x.ParentType != genericVideoType)
+            .Select(x => x.ChildId)
+            .Distinct()
             .ToList();
 
-        if (alternateVersionsToUpdate.Count == 0)
+        if (wrongTypeChildIds.Count == 0)
         {
-            _logger.LogInformation("No alternate version items need type updates.");
+            _logger.LogInformation("No wrong-type alternate version items found.");
             return;
         }
 
-        _logger.LogInformation("Found {Count} alternate version items to update.", alternateVersionsToUpdate.Count);
+        _logger.LogInformation("Found {Count} wrong-type alternate version items to remove.", wrongTypeChildIds.Count);
 
-        foreach (var item in alternateVersionsToUpdate)
+        foreach (var childId in wrongTypeChildIds)
         {
-            item.Child.Type = item.ParentType;
-            _logger.LogDebug(
-                "Updating item {ChildId} type from {OldType} to {NewType}",
-                item.ChildId,
-                genericVideoType,
-                item.ParentType);
+            var item = _libraryManager.GetItemById(childId);
+            if (item is not null)
+            {
+                _libraryManager.DeleteItem(item, new DeleteOptions { DeleteFileLocation = false });
+            }
         }
 
-        context.SaveChanges();
-        _logger.LogInformation("Successfully updated {Count} alternate version item types.", alternateVersionsToUpdate.Count);
+        _logger.LogInformation("Removed {Count} wrong-type alternate version items. They will be recreated with the correct type on next library scan.", wrongTypeChildIds.Count);
     }
 
     private void CleanupOrphanedLinkedChildren(JellyfinDbContext context)
diff --git a/MediaBrowser.Controller/Entities/Movies/Movie.cs b/MediaBrowser.Controller/Entities/Movies/Movie.cs
index 5ab149a49d..8f06d18d63 100644
--- a/MediaBrowser.Controller/Entities/Movies/Movie.cs
+++ b/MediaBrowser.Controller/Entities/Movies/Movie.cs
@@ -109,7 +109,14 @@ namespace MediaBrowser.Controller.Entities.Movies
 
             if (LibraryManager.GetItemById(id) is not Movie movie)
             {
-                movie = LibraryManager.ResolvePath(FileSystem.GetFileSystemInfo(path)) as Movie;
+                // Pass parent and collectionType so the resolver creates a Movie
+                // instead of a generic Video
+                var parentFolder = GetParent() as Folder;
+                var collectionType = GetParents().OfType<ICollectionFolder>().FirstOrDefault()?.CollectionType;
+                movie = LibraryManager.ResolvePath(
+                    FileSystem.GetFileSystemInfo(path),
+                    parentFolder,
+                    collectionType: collectionType) as Movie;
 
                 newOptions.ForceSave = true;
             }
diff --git a/MediaBrowser.Controller/Entities/Video.cs b/MediaBrowser.Controller/Entities/Video.cs
index 21aa50b49d..e06875b64c 100644
--- a/MediaBrowser.Controller/Entities/Video.cs
+++ b/MediaBrowser.Controller/Entities/Video.cs
@@ -457,10 +457,20 @@ namespace MediaBrowser.Controller.Entities
                 {
                     RefreshLinkedAlternateVersions();
 
-                    var tasks = LocalAlternateVersions
-                        .Select(i => RefreshMetadataForVersions(options, false, i, cancellationToken));
+                    if (LocalAlternateVersions.Length > 0)
+                    {
+                        // Check if LinkedChildren are in sync before processing
+                        var existingLinkCount = LibraryManager.GetLocalAlternateVersionIds(this).Count();
+                        var tasks = LocalAlternateVersions
+                            .Select(i => RefreshMetadataForVersions(options, false, i, cancellationToken));
+
+                        await Task.WhenAll(tasks).ConfigureAwait(false);
 
-                    await Task.WhenAll(tasks).ConfigureAwait(false);
+                        if (existingLinkCount != LocalAlternateVersions.Length)
+                        {
+                            hasChanges = true;
+                        }
+                    }
                 }
             }
 
@@ -470,6 +480,15 @@ namespace MediaBrowser.Controller.Entities
         protected virtual async Task RefreshMetadataForVersions(MetadataRefreshOptions options, bool copyTitleMetadata, string path, CancellationToken cancellationToken)
         {
             await RefreshMetadataForOwnedVideo(options, copyTitleMetadata, path, cancellationToken).ConfigureAwait(false);
+
+            // Create LinkedChild entry for this local alternate version
+            // This ensures the relationship exists in the database even if the alternate version
+            // was created after the primary video was first saved
+            var id = LibraryManager.GetNewItemId(path, GetType());
+            if (LibraryManager.GetItemById(id) is Video video)
+            {
+                LibraryManager.UpsertLinkedChild(Id, video.Id, LinkedChildType.LocalAlternateVersion);
+            }
         }
 
         private new async Task RefreshMetadataForOwnedVideo(MetadataRefreshOptions options, bool copyTitleMetadata, string path, CancellationToken cancellationToken)
@@ -496,7 +515,12 @@ namespace MediaBrowser.Controller.Entities
 
             if (LibraryManager.GetItemById(id) is not Video video)
             {
-                video = LibraryManager.ResolvePath(FileSystem.GetFileSystemInfo(path)) as Video;
+                var parentFolder = GetParent() as Folder;
+                var collectionType = GetParents().OfType<ICollectionFolder>().FirstOrDefault()?.CollectionType;
+                video = LibraryManager.ResolvePath(
+                    FileSystem.GetFileSystemInfo(path),
+                    parentFolder,
+                    collectionType: collectionType) as Video;
 
                 newOptions.ForceSave = true;
             }
@@ -512,11 +536,6 @@ namespace MediaBrowser.Controller.Entities
             }
 
             await RefreshMetadataForOwnedItem(video, copyTitleMetadata, newOptions, cancellationToken).ConfigureAwait(false);
-
-            // Create LinkedChild entry for this local alternate version
-            // This ensures the relationship exists in the database even if the alternate version
-            // was created after the primary video was first saved
-            LibraryManager.UpsertLinkedChild(Id, video.Id, LinkedChildType.LocalAlternateVersion);
         }
 
         private void RefreshLinkedAlternateVersions()
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index 3b3295c57d..453d9f7c2b 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -59,11 +59,13 @@ namespace MediaBrowser.Controller.Library
         /// <param name="fileInfo">The file information.</param>
         /// <param name="parent">The parent.</param>
         /// <param name="directoryService">An instance of <see cref="IDirectoryService"/>.</param>
+        /// <param name="collectionType">The collection type of the library containing this item.</param>
         /// <returns>BaseItem.</returns>
         BaseItem? ResolvePath(
             FileSystemMetadata fileInfo,
             Folder? parent = null,
-            IDirectoryService? directoryService = null);
+            IDirectoryService? directoryService = null,
+            CollectionType? collectionType = null);
 
         /// <summary>
         /// Resolves a set of files into a list of BaseItem.
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/SqliteDatabaseProvider.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/SqliteDatabaseProvider.cs
index da63df8e29..6347bac21a 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/SqliteDatabaseProvider.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/SqliteDatabaseProvider.cs
@@ -77,7 +77,8 @@ public sealed class SqliteDatabaseProvider : IJellyfinDatabaseProvider
                 sqLiteOptions => sqLiteOptions.MigrationsAssembly(GetType().Assembly))
             // TODO: Remove when https://github.com/dotnet/efcore/pull/35873 is merged & released
             .ConfigureWarnings(warnings =>
-                warnings.Ignore(RelationalEventId.NonTransactionalMigrationOperationWarning))
+                warnings.Ignore(RelationalEventId.NonTransactionalMigrationOperationWarning)
+                    .Ignore(RelationalEventId.MultipleCollectionIncludeWarning))
             .AddInterceptors(new PragmaConnectionInterceptor(
                 _logger,
                 GetOption<int?>(customOptions, "cacheSize", e => int.Parse(e, CultureInfo.InvariantCulture)),
-- 
cgit v1.2.3


From 71594b4a9a1fa91fbb03e6e8f79090465619bd9c Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sun, 8 Feb 2026 17:22:52 +0100
Subject: Fix multiple version resolution

---
 .../Library/LibraryManager.cs                      | 79 +++++++++++++++++-----
 .../Localization/Core/en-US.json                   |  2 +-
 .../Item/BaseItemRepository.cs                     |  5 +-
 MediaBrowser.Controller/Entities/Movies/Movie.cs   | 52 --------------
 MediaBrowser.Controller/Entities/Video.cs          | 70 ++++++++++---------
 MediaBrowser.Controller/Library/ILibraryManager.cs | 16 +++++
 .../SqliteDatabaseProvider.cs                      | 14 ++--
 7 files changed, 125 insertions(+), 113 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 6bb5f87d03..df259c303f 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -704,6 +704,57 @@ namespace Emby.Server.Implementations.Library
         public BaseItem? ResolvePath(FileSystemMetadata fileInfo, Folder? parent = null, IDirectoryService? directoryService = null, CollectionType? collectionType = null)
             => ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent, collectionType);
 
+        /// <inheritdoc />
+        public Video? ResolveAlternateVersion(string path, Type expectedVideoType, Folder? parent, CollectionType? collectionType)
+        {
+            // Clean up any existing item saved with wrong type (e.g. Video instead of Movie).
+            // This happens when items were previously resolved without proper type context
+            // in mixed-content libraries where collectionType is null.
+            var expectedId = GetNewItemId(path, expectedVideoType);
+            if (expectedVideoType != typeof(Video))
+            {
+                var wrongTypeId = GetNewItemId(path, typeof(Video));
+                if (!wrongTypeId.Equals(expectedId) && GetItemById(wrongTypeId) is Video wrongTypeItem)
+                {
+                    _logger.LogInformation(
+                        "Removing alternate version with wrong type {WrongType}, expected {ExpectedType}: {Path}",
+                        wrongTypeItem.GetType().Name,
+                        expectedVideoType.Name,
+                        path);
+                    DeleteItem(wrongTypeItem, new DeleteOptions { DeleteFileLocation = false });
+                }
+            }
+
+            var resolved = ResolvePath(
+                _fileSystem.GetFileSystemInfo(path),
+                parent,
+                collectionType: collectionType) as Video;
+
+            if (resolved is null)
+            {
+                return null;
+            }
+
+            // Ensure the alternate version has the same concrete type as the primary video.
+            // ResolvePath may return a generic Video for files in mixed-content libraries
+            // where collectionType is null, even though the primary is a Movie/Episode/etc.
+            if (resolved.GetType() != expectedVideoType)
+            {
+                if (Activator.CreateInstance(expectedVideoType) is Video correctVideo)
+                {
+                    correctVideo.Path = resolved.Path;
+                    correctVideo.Name = resolved.Name;
+                    correctVideo.VideoType = resolved.VideoType;
+                    correctVideo.ProductionYear = resolved.ProductionYear;
+                    correctVideo.ExtraType = resolved.ExtraType;
+                    resolved = correctVideo;
+                }
+            }
+
+            resolved.Id = expectedId;
+            return resolved;
+        }
+
         private BaseItem? ResolvePath(
             FileSystemMetadata fileInfo,
             IDirectoryService directoryService,
@@ -2125,14 +2176,8 @@ namespace Emby.Server.Implementations.Library
                         if (GetItemById(altId) is null && !allItems.Any(i => i.Id.Equals(altId)))
                         {
                             // Alternate version doesn't exist, resolve and create it
-                            // Pass parent and collectionType so the resolver creates the correct type
-                            // (e.g. Movie instead of generic Video)
-                            var altVideo = ResolvePath(
-                                _fileSystem.GetFileSystemInfo(path),
-                                new DirectoryService(_fileSystem),
-                                null,
-                                parentFolder,
-                                parentCollectionType) as Video;
+                            // ensuring it has the same type as the primary video
+                            var altVideo = ResolveAlternateVersion(path, videoType, parentFolder, parentCollectionType);
                             if (altVideo is not null)
                             {
                                 altVideo.OwnerId = video.Id;
@@ -2333,14 +2378,8 @@ namespace Emby.Server.Implementations.Library
                         if (GetItemById(altId) is null && !allItems.Any(i => i.Id.Equals(altId)))
                         {
                             // Alternate version doesn't exist, resolve and create it
-                            // Pass parent and collectionType so the resolver creates the correct type
-                            // (e.g. Movie instead of generic Video)
-                            var altVideo = ResolvePath(
-                                _fileSystem.GetFileSystemInfo(path),
-                                new DirectoryService(_fileSystem),
-                                null,
-                                parentFolder,
-                                parentCollectionType) as Video;
+                            // ensuring it has the same type as the primary video
+                            var altVideo = ResolveAlternateVersion(path, videoType, parentFolder, parentCollectionType);
                             if (altVideo is not null)
                             {
                                 altVideo.OwnerId = video.Id;
@@ -2353,6 +2392,14 @@ namespace Emby.Server.Implementations.Library
 
             _itemRepository.SaveItems(allItems, cancellationToken);
 
+            foreach (var item in allItems)
+            {
+                if (!items.Contains(item))
+                {
+                    RegisterItem(item);
+                }
+            }
+
             if (parent is Folder folder)
             {
                 folder.Children = null;
diff --git a/Emby.Server.Implementations/Localization/Core/en-US.json b/Emby.Server.Implementations/Localization/Core/en-US.json
index c40448151c..45b1cbb6a0 100644
--- a/Emby.Server.Implementations/Localization/Core/en-US.json
+++ b/Emby.Server.Implementations/Localization/Core/en-US.json
@@ -130,7 +130,7 @@
     "TaskOptimizeDatabaseDescription": "Compacts database and truncates free space. Running this task after scanning the library or doing other changes that imply database modifications might improve performance.",
     "TaskKeyframeExtractor": "Keyframe Extractor",
     "TaskKeyframeExtractorDescription": "Extracts keyframes from video files to create more precise HLS playlists. This task may run for a long time.",
-"TaskExtractMediaSegments": "Media Segment Scan",
+    "TaskExtractMediaSegments": "Media Segment Scan",
     "TaskExtractMediaSegmentsDescription": "Extracts or obtains media segments from MediaSegment enabled plugins.",
     "TaskMoveTrickplayImages": "Migrate Trickplay Image Location",
     "TaskMoveTrickplayImagesDescription": "Moves existing trickplay files according to the library settings.",
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 99e85d946d..3cb40fa9ec 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -304,7 +304,7 @@ public sealed class BaseItemRepository
         }
 
         dbQuery = ApplyQueryPaging(dbQuery, filter);
-        dbQuery = ApplyNavigations(dbQuery, filter);
+        dbQuery = ApplyNavigations(dbQuery, filter).AsSplitQuery();
 
         result.Items = dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).Where(dto => dto is not null).ToArray()!;
         result.StartIndex = filter.StartIndex ?? 0;
@@ -1850,7 +1850,8 @@ public sealed class BaseItemRepository
             .Include(e => e.LockedFields)
             .Include(e => e.UserData)
             .Include(e => e.Images)
-            .Include(e => e.LinkedChildEntities);
+            .Include(e => e.LinkedChildEntities)
+            .AsSingleQuery();
 
         var item = dbQuery.FirstOrDefault(e => e.Id == id);
         if (item is null)
diff --git a/MediaBrowser.Controller/Entities/Movies/Movie.cs b/MediaBrowser.Controller/Entities/Movies/Movie.cs
index 8f06d18d63..e8817a29cf 100644
--- a/MediaBrowser.Controller/Entities/Movies/Movie.cs
+++ b/MediaBrowser.Controller/Entities/Movies/Movie.cs
@@ -85,58 +85,6 @@ namespace MediaBrowser.Controller.Entities.Movies
             return info;
         }
 
-        protected override async Task RefreshMetadataForVersions(MetadataRefreshOptions options, bool copyTitleMetadata, string path, CancellationToken cancellationToken)
-        {
-            var newOptions = new MetadataRefreshOptions(options)
-            {
-                SearchResult = null
-            };
-
-            var id = LibraryManager.GetNewItemId(path, typeof(Movie));
-
-            // Check if the file still exists
-            if (!FileSystem.FileExists(path))
-            {
-                // File was removed - clean up any orphaned database entry
-                if (LibraryManager.GetItemById(id) is Movie orphanedMovie && orphanedMovie.OwnerId.Equals(Id))
-                {
-                    Logger.LogInformation("Alternate version file no longer exists, removing orphaned item: {Path}", path);
-                    LibraryManager.DeleteItem(orphanedMovie, new DeleteOptions { DeleteFileLocation = false });
-                }
-
-                return;
-            }
-
-            if (LibraryManager.GetItemById(id) is not Movie movie)
-            {
-                // Pass parent and collectionType so the resolver creates a Movie
-                // instead of a generic Video
-                var parentFolder = GetParent() as Folder;
-                var collectionType = GetParents().OfType<ICollectionFolder>().FirstOrDefault()?.CollectionType;
-                movie = LibraryManager.ResolvePath(
-                    FileSystem.GetFileSystemInfo(path),
-                    parentFolder,
-                    collectionType: collectionType) as Movie;
-
-                newOptions.ForceSave = true;
-            }
-
-            if (movie is null)
-            {
-                return;
-            }
-
-            if (movie.OwnerId.Equals(Guid.Empty))
-            {
-                movie.OwnerId = Id;
-            }
-
-            await RefreshMetadataForOwnedItem(movie, copyTitleMetadata, newOptions, cancellationToken).ConfigureAwait(false);
-
-            // Create LinkedChild entry for this local alternate version
-            LibraryManager.UpsertLinkedChild(Id, movie.Id, LinkedChildType.LocalAlternateVersion);
-        }
-
         /// <inheritdoc />
         public override bool BeforeMetadataRefresh(bool replaceAllMetadata)
         {
diff --git a/MediaBrowser.Controller/Entities/Video.cs b/MediaBrowser.Controller/Entities/Video.cs
index e06875b64c..02b3b31d3b 100644
--- a/MediaBrowser.Controller/Entities/Video.cs
+++ b/MediaBrowser.Controller/Entities/Video.cs
@@ -453,38 +453,45 @@ namespace MediaBrowser.Controller.Entities
             // The additional parts won't have additional parts themselves
             if (IsFileProtocol && SupportsOwnedItems)
             {
-                if (!IsStacked)
-                {
-                    RefreshLinkedAlternateVersions();
-
-                    if (LocalAlternateVersions.Length > 0)
-                    {
-                        // Check if LinkedChildren are in sync before processing
-                        var existingLinkCount = LibraryManager.GetLocalAlternateVersionIds(this).Count();
-                        var tasks = LocalAlternateVersions
-                            .Select(i => RefreshMetadataForVersions(options, false, i, cancellationToken));
+                // Check if LinkedChildren are in sync before processing
+                var existingVersionCount = LibraryManager.GetLocalAlternateVersionIds(this).Count();
+                var tasks = LocalAlternateVersions
+                    .Select(i => RefreshMetadataForVersions(options, false, i, cancellationToken));
 
-                        await Task.WhenAll(tasks).ConfigureAwait(false);
+                await Task.WhenAll(tasks).ConfigureAwait(false);
 
-                        if (existingLinkCount != LocalAlternateVersions.Length)
-                        {
-                            hasChanges = true;
-                        }
-                    }
+                if (existingVersionCount != LocalAlternateVersions.Length)
+                {
+                    hasChanges = true;
                 }
             }
 
             return hasChanges;
         }
 
-        protected virtual async Task RefreshMetadataForVersions(MetadataRefreshOptions options, bool copyTitleMetadata, string path, CancellationToken cancellationToken)
+        private async Task RefreshMetadataForVersions(MetadataRefreshOptions options, bool copyTitleMetadata, string path, CancellationToken cancellationToken)
         {
+            // Ensure the alternate version exists with the correct type (e.g. Movie, not Video)
+            // before refreshing. This must happen here rather than in RefreshMetadataForOwnedVideo
+            // because that method is also used for stacked parts which should keep their resolved type.
+            var id = LibraryManager.GetNewItemId(path, GetType());
+            if (LibraryManager.GetItemById(id) is not Video && FileSystem.FileExists(path))
+            {
+                var parentFolder = GetParent() as Folder;
+                var collectionType = LibraryManager.GetContentType(this);
+                var altVideo = LibraryManager.ResolveAlternateVersion(path, GetType(), parentFolder, collectionType);
+                if (altVideo is not null)
+                {
+                    altVideo.OwnerId = Id;
+                    LibraryManager.CreateItem(altVideo, GetParent());
+                }
+            }
+
             await RefreshMetadataForOwnedVideo(options, copyTitleMetadata, path, cancellationToken).ConfigureAwait(false);
 
             // Create LinkedChild entry for this local alternate version
             // This ensures the relationship exists in the database even if the alternate version
             // was created after the primary video was first saved
-            var id = LibraryManager.GetNewItemId(path, GetType());
             if (LibraryManager.GetItemById(id) is Video video)
             {
                 LibraryManager.UpsertLinkedChild(Id, video.Id, LinkedChildType.LocalAlternateVersion);
@@ -516,18 +523,21 @@ namespace MediaBrowser.Controller.Entities
             if (LibraryManager.GetItemById(id) is not Video video)
             {
                 var parentFolder = GetParent() as Folder;
-                var collectionType = GetParents().OfType<ICollectionFolder>().FirstOrDefault()?.CollectionType;
+                var collectionType = LibraryManager.GetContentType(this);
                 video = LibraryManager.ResolvePath(
                     FileSystem.GetFileSystemInfo(path),
                     parentFolder,
                     collectionType: collectionType) as Video;
 
-                newOptions.ForceSave = true;
-            }
+                if (video is null)
+                {
+                    return;
+                }
 
-            if (video is null)
-            {
-                return;
+                video.Id = id;
+                video.OwnerId = Id;
+                LibraryManager.CreateItem(video, parentFolder);
+                newOptions.ForceSave = true;
             }
 
             if (video.OwnerId.IsEmpty())
@@ -538,18 +548,6 @@ namespace MediaBrowser.Controller.Entities
             await RefreshMetadataForOwnedItem(video, copyTitleMetadata, newOptions, cancellationToken).ConfigureAwait(false);
         }
 
-        private void RefreshLinkedAlternateVersions()
-        {
-            foreach (var child in LinkedAlternateVersions)
-            {
-                // Reset the cached value
-                if (child.ItemId.IsNullOrEmpty())
-                {
-                    child.ItemId = null;
-                }
-            }
-        }
-
         /// <inheritdoc />
         public override async Task UpdateToRepositoryAsync(ItemUpdateType updateReason, CancellationToken cancellationToken)
         {
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index 453d9f7c2b..e73dede1d4 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -67,6 +67,22 @@ namespace MediaBrowser.Controller.Library
             IDirectoryService? directoryService = null,
             CollectionType? collectionType = null);
 
+        /// <summary>
+        /// Resolves a video file as an alternate version of a primary video, ensuring the result
+        /// has the same concrete type as the primary (e.g. Movie instead of generic Video).
+        /// Also cleans up any existing item with the wrong type from a previous scan.
+        /// </summary>
+        /// <param name="path">The file path of the alternate version.</param>
+        /// <param name="expectedVideoType">The expected concrete type (same as the primary video).</param>
+        /// <param name="parent">The parent folder.</param>
+        /// <param name="collectionType">The collection type of the library.</param>
+        /// <returns>A correctly-typed Video, or null if resolution fails.</returns>
+        Video? ResolveAlternateVersion(
+            string path,
+            Type expectedVideoType,
+            Folder? parent,
+            CollectionType? collectionType);
+
         /// <summary>
         /// Resolves a set of files into a list of BaseItem.
         /// </summary>
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/SqliteDatabaseProvider.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/SqliteDatabaseProvider.cs
index 6347bac21a..7f42623c3d 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/SqliteDatabaseProvider.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/SqliteDatabaseProvider.cs
@@ -60,11 +60,13 @@ public sealed class SqliteDatabaseProvider : IJellyfinDatabaseProvider
 
         var customOptions = databaseConfiguration.CustomProviderOptions?.Options;
 
-        var sqliteConnectionBuilder = new SqliteConnectionStringBuilder();
-        sqliteConnectionBuilder.DataSource = Path.Combine(_applicationPaths.DataPath, "jellyfin.db");
-        sqliteConnectionBuilder.Cache = GetOption(customOptions, "cache", Enum.Parse<SqliteCacheMode>, () => SqliteCacheMode.Default);
-        sqliteConnectionBuilder.Pooling = GetOption(customOptions, "pooling", e => e.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase), () => true);
-        sqliteConnectionBuilder.DefaultTimeout = GetOption(customOptions, "command-timeout", int.Parse, () => 30);
+        var sqliteConnectionBuilder = new SqliteConnectionStringBuilder
+        {
+            DataSource = Path.Combine(_applicationPaths.DataPath, "jellyfin.db"),
+            Cache = GetOption(customOptions, "cache", Enum.Parse<SqliteCacheMode>, () => SqliteCacheMode.Default),
+            Pooling = GetOption(customOptions, "pooling", e => e.Equals(bool.TrueString, StringComparison.OrdinalIgnoreCase), () => true),
+            DefaultTimeout = GetOption(customOptions, "command-timeout", int.Parse, () => 60)
+        };
 
         var connectionString = sqliteConnectionBuilder.ToString();
 
@@ -156,7 +158,7 @@ public sealed class SqliteDatabaseProvider : IJellyfinDatabaseProvider
     /// <inheritdoc />
     public Task RestoreBackupFast(string key, CancellationToken cancellationToken)
     {
-        // ensure there are absolutly no dangling Sqlite connections.
+        // ensure there are absolutely no dangling Sqlite connections.
         SqliteConnection.ClearAllPools();
         var path = Path.Combine(_applicationPaths.DataPath, "jellyfin.db");
         var backupFile = Path.Combine(_applicationPaths.DataPath, BackupFolderName, $"{key}_jellyfin.db");
-- 
cgit v1.2.3


From 3439d3c017a06604e7b471a1063a8467306f78f2 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sun, 15 Feb 2026 23:12:52 +0100
Subject: Migrate PrimaryVersionId to GUID and fix assignment

---
 .../Library/LibraryManager.cs                      |   11 +-
 Jellyfin.Api/Controllers/VideosController.cs       |    8 +-
 .../Routines/FixIncorrectOwnerIdRelationships.cs   |    4 +-
 .../Migrations/Routines/MigrateLibraryDb.cs        |    4 +-
 MediaBrowser.Controller/Entities/Folder.cs         |    2 +-
 MediaBrowser.Controller/Entities/Video.cs          |   34 +-
 .../Entities/BaseItemEntity.cs                     |    2 +-
 ...201634_ChangePrimaryVersionIdToGuid.Designer.cs | 1791 ++++++++++++++++++++
 .../20260215201634_ChangePrimaryVersionIdToGuid.cs |   54 +
 .../Migrations/JellyfinDbModelSnapshot.cs          |    4 +-
 10 files changed, 1880 insertions(+), 34 deletions(-)
 create mode 100644 src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260215201634_ChangePrimaryVersionIdToGuid.Designer.cs
 create mode 100644 src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260215201634_ChangePrimaryVersionIdToGuid.cs

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index df259c303f..7517dc03ba 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -408,7 +408,7 @@ namespace Emby.Server.Implementations.Library
 
             // If deleting a primary version video, clear PrimaryVersionId from alternate versions
             // OwnerId check: items with OwnerId set are alternate versions or extras, not primaries
-            if (item is Video video && string.IsNullOrEmpty(video.PrimaryVersionId) && video.OwnerId.IsEmpty())
+            if (item is Video video && !video.PrimaryVersionId.HasValue && video.OwnerId.IsEmpty())
             {
                 var alternateVersions = GetLocalAlternateVersionIds(video)
                     .Concat(GetLinkedAlternateVersions(video).Select(v => v.Id))
@@ -435,16 +435,15 @@ namespace Emby.Server.Implementations.Library
                     // Update remaining alternates to point to new primary
                     foreach (var alternate in alternateVersions.Skip(1))
                     {
-                        alternate.SetPrimaryVersionId(newPrimary.Id.ToString("N", CultureInfo.InvariantCulture));
+                        alternate.SetPrimaryVersionId(newPrimary.Id);
                         alternate.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
                     }
                 }
             }
-            else if (item is Video alternateVideo && !string.IsNullOrEmpty(alternateVideo.PrimaryVersionId)
-                && Guid.TryParse(alternateVideo.PrimaryVersionId, out var primaryId))
+            else if (item is Video alternateVideo && alternateVideo.PrimaryVersionId.HasValue)
             {
                 // If deleting an alternate version, re-route references to its primary
-                _itemRepository.RerouteLinkedChildren(alternateVideo.Id, primaryId);
+                _itemRepository.RerouteLinkedChildren(alternateVideo.Id, alternateVideo.PrimaryVersionId.Value);
             }
 
             var children = item.IsFolder
@@ -2181,6 +2180,7 @@ namespace Emby.Server.Implementations.Library
                             if (altVideo is not null)
                             {
                                 altVideo.OwnerId = video.Id;
+                                altVideo.SetPrimaryVersionId(video.Id);
                                 allItems.Add(altVideo);
                             }
                         }
@@ -2383,6 +2383,7 @@ namespace Emby.Server.Implementations.Library
                             if (altVideo is not null)
                             {
                                 altVideo.OwnerId = video.Id;
+                                altVideo.SetPrimaryVersionId(video.Id);
                                 allItems.Add(altVideo);
                             }
                         }
diff --git a/Jellyfin.Api/Controllers/VideosController.cs b/Jellyfin.Api/Controllers/VideosController.cs
index 1c8b695458..155871770a 100644
--- a/Jellyfin.Api/Controllers/VideosController.cs
+++ b/Jellyfin.Api/Controllers/VideosController.cs
@@ -147,9 +147,9 @@ public class VideosController : BaseJellyfinApiController
             return NotFound();
         }
 
-        if (item.LinkedAlternateVersions.Length == 0)
+        if (item.LinkedAlternateVersions.Length == 0 && item.PrimaryVersionId.HasValue)
         {
-            item = _libraryManager.GetItemById<Video>(Guid.Parse(item.PrimaryVersionId));
+            item = _libraryManager.GetItemById<Video>(item.PrimaryVersionId.Value);
         }
 
         if (item is null)
@@ -197,7 +197,7 @@ public class VideosController : BaseJellyfinApiController
             return BadRequest("Please supply at least two videos to merge.");
         }
 
-        var primaryVersion = items.FirstOrDefault(i => i.MediaSourceCount > 1 && string.IsNullOrEmpty(i.PrimaryVersionId));
+        var primaryVersion = items.FirstOrDefault(i => i.MediaSourceCount > 1 && !i.PrimaryVersionId.HasValue);
         if (primaryVersion is null)
         {
             primaryVersion = items
@@ -218,7 +218,7 @@ public class VideosController : BaseJellyfinApiController
 
         foreach (var item in items.Where(i => !i.Id.Equals(primaryVersion.Id)))
         {
-            item.SetPrimaryVersionId(primaryVersion.Id.ToString("N", CultureInfo.InvariantCulture));
+            item.SetPrimaryVersionId(primaryVersion.Id);
 
             await item.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
 
diff --git a/Jellyfin.Server/Migrations/Routines/FixIncorrectOwnerIdRelationships.cs b/Jellyfin.Server/Migrations/Routines/FixIncorrectOwnerIdRelationships.cs
index 0d12f065c1..a8445d6da8 100644
--- a/Jellyfin.Server/Migrations/Routines/FixIncorrectOwnerIdRelationships.cs
+++ b/Jellyfin.Server/Migrations/Routines/FixIncorrectOwnerIdRelationships.cs
@@ -284,7 +284,7 @@ public class FixIncorrectOwnerIdRelationships : IAsyncMigrationRoutine
                 lc => lc.ChildId,
                 item => item.Id,
                 (lc, item) => new { lc.ParentId, lc.ChildId, item.PrimaryVersionId })
-            .Where(x => x.PrimaryVersionId == null || x.PrimaryVersionId != x.ParentId.ToString())
+            .Where(x => !x.PrimaryVersionId.HasValue || !x.PrimaryVersionId.Value.Equals(x.ParentId))
             .ToListAsync(cancellationToken)
             .ConfigureAwait(false);
 
@@ -307,7 +307,7 @@ public class FixIncorrectOwnerIdRelationships : IAsyncMigrationRoutine
 
             if (childItem is not null)
             {
-                childItem.PrimaryVersionId = link.ParentId.ToString();
+                childItem.PrimaryVersionId = link.ParentId;
                 updatedCount++;
             }
         }
diff --git a/Jellyfin.Server/Migrations/Routines/MigrateLibraryDb.cs b/Jellyfin.Server/Migrations/Routines/MigrateLibraryDb.cs
index 996d55033e..1f4cab52e7 100644
--- a/Jellyfin.Server/Migrations/Routines/MigrateLibraryDb.cs
+++ b/Jellyfin.Server/Migrations/Routines/MigrateLibraryDb.cs
@@ -1074,9 +1074,9 @@ internal class MigrateLibraryDb : IDatabaseMigrationRoutine
             entity.OriginalTitle = originalTitle;
         }
 
-        if (reader.TryGetString(index++, out var primaryVersionId))
+        if (reader.TryGetString(index++, out var primaryVersionId) && Guid.TryParse(primaryVersionId, out var primaryVersionGuid))
         {
-            entity.PrimaryVersionId = primaryVersionId;
+            entity.PrimaryVersionId = primaryVersionGuid;
         }
 
         if (reader.TryReadDateTime(index++, out var dateLastMediaAdded))
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index 7e4205b6ba..525a4bc334 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -480,7 +480,7 @@ namespace MediaBrowser.Controller.Entities
                         if (item is Video video)
                         {
                             // Check via PrimaryVersionId
-                            if (!string.IsNullOrEmpty(video.PrimaryVersionId))
+                            if (video.PrimaryVersionId.HasValue)
                             {
                                 Logger.LogDebug("Item is an alternate version (via PrimaryVersionId), skipping deletion: {Path}", item.Path ?? item.Name);
                                 continue;
diff --git a/MediaBrowser.Controller/Entities/Video.cs b/MediaBrowser.Controller/Entities/Video.cs
index 02b3b31d3b..21b5d5d77b 100644
--- a/MediaBrowser.Controller/Entities/Video.cs
+++ b/MediaBrowser.Controller/Entities/Video.cs
@@ -41,7 +41,7 @@ namespace MediaBrowser.Controller.Entities
         }
 
         [JsonIgnore]
-        public string PrimaryVersionId { get; set; }
+        public Guid? PrimaryVersionId { get; set; }
 
         public string[] AdditionalParts { get; set; }
 
@@ -254,9 +254,9 @@ namespace MediaBrowser.Controller.Entities
         private int GetMediaSourceCount(HashSet<Guid> callstack = null)
         {
             callstack ??= new();
-            if (!string.IsNullOrEmpty(PrimaryVersionId))
+            if (PrimaryVersionId.HasValue)
             {
-                var item = LibraryManager.GetItemById(PrimaryVersionId);
+                var item = LibraryManager.GetItemById(PrimaryVersionId.Value);
                 if (item is Video video)
                 {
                     if (callstack.Contains(video.Id))
@@ -317,25 +317,17 @@ namespace MediaBrowser.Controller.Entities
             return list;
         }
 
-        public void SetPrimaryVersionId(string id)
+        public void SetPrimaryVersionId(Guid? id)
         {
-            if (string.IsNullOrEmpty(id))
-            {
-                PrimaryVersionId = null;
-            }
-            else
-            {
-                PrimaryVersionId = id;
-            }
-
+            PrimaryVersionId = id;
             PresentationUniqueKey = CreatePresentationUniqueKey();
         }
 
         public override string CreatePresentationUniqueKey()
         {
-            if (!string.IsNullOrEmpty(PrimaryVersionId))
+            if (PrimaryVersionId.HasValue)
             {
-                return PrimaryVersionId;
+                return PrimaryVersionId.Value.ToString("N", CultureInfo.InvariantCulture);
             }
 
             return base.CreatePresentationUniqueKey();
@@ -483,6 +475,7 @@ namespace MediaBrowser.Controller.Entities
                 if (altVideo is not null)
                 {
                     altVideo.OwnerId = Id;
+                    altVideo.SetPrimaryVersionId(Id);
                     LibraryManager.CreateItem(altVideo, GetParent());
                 }
             }
@@ -495,6 +488,13 @@ namespace MediaBrowser.Controller.Entities
             if (LibraryManager.GetItemById(id) is Video video)
             {
                 LibraryManager.UpsertLinkedChild(Id, video.Id, LinkedChildType.LocalAlternateVersion);
+
+                // Ensure PrimaryVersionId is set for existing alternate versions that may not have it
+                if (!video.PrimaryVersionId.HasValue)
+                {
+                    video.SetPrimaryVersionId(Id);
+                    await video.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
+                }
             }
         }
 
@@ -612,9 +612,9 @@ namespace MediaBrowser.Controller.Entities
 
             list.AddRange(LibraryManager.GetLinkedAlternateVersions(this).Select(i => ((BaseItem)i, MediaSourceType.Grouping)));
 
-            if (!string.IsNullOrEmpty(PrimaryVersionId))
+            if (PrimaryVersionId.HasValue)
             {
-                if (LibraryManager.GetItemById(PrimaryVersionId) is Video primary)
+                if (LibraryManager.GetItemById(PrimaryVersionId.Value) is Video primary)
                 {
                     var existingIds = list.Select(i => i.Item1.Id).ToList();
                     list.Add((primary, MediaSourceType.Grouping));
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/BaseItemEntity.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/BaseItemEntity.cs
index ff25765363..76c847e5f0 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/BaseItemEntity.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/BaseItemEntity.cs
@@ -96,7 +96,7 @@ public class BaseItemEntity
 
     public string? OriginalTitle { get; set; }
 
-    public string? PrimaryVersionId { get; set; }
+    public Guid? PrimaryVersionId { get; set; }
 
     public DateTime? DateLastMediaAdded { get; set; }
 
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260215201634_ChangePrimaryVersionIdToGuid.Designer.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260215201634_ChangePrimaryVersionIdToGuid.Designer.cs
new file mode 100644
index 0000000000..0184154566
--- /dev/null
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260215201634_ChangePrimaryVersionIdToGuid.Designer.cs
@@ -0,0 +1,1791 @@
+// <auto-generated />
+using System;
+using Jellyfin.Database.Implementations;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Jellyfin.Database.Providers.Sqlite.Migrations
+{
+    [DbContext(typeof(JellyfinDbContext))]
+    [Migration("20260215201634_ChangePrimaryVersionIdToGuid")]
+    partial class ChangePrimaryVersionIdToGuid
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.3");
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DayOfWeek")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("EndHour")
+                        .HasColumnType("REAL");
+
+                    b.Property<double>("StartHour")
+                        .HasColumnType("REAL");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccessSchedules");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ActivityLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LogSeverity")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Overview")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ShortOverview")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DateCreated");
+
+                    b.ToTable("ActivityLogs");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AncestorId", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ParentItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "ParentItemId");
+
+                    b.HasIndex("ParentItemId");
+
+                    b.ToTable("AncestorIds");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AttachmentStreamInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Filename")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MimeType")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "Index");
+
+                    b.ToTable("AttachmentStreamInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AlbumArtists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Artists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Audio")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("ChannelId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CleanName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("CommunityRating")
+                        .HasColumnType("REAL");
+
+                    b.Property<float?>("CriticRating")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("CustomRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastMediaAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastRefreshed")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastSaved")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EpisodeTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalSeriesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalServiceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ExtraType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ForcedSortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Genres")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("IndexNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("InheritedParentalRatingSubValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("InheritedParentalRatingValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsFolder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsInMixedFolder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsLocked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsMovie")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsRepeat")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsSeries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsVirtualItem")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<float?>("LUFS")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("MediaType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("NormalizationGain")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("OfficialRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("OwnerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentIndexNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredMetadataCountryCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredMetadataLanguage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("PremiereDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PresentationUniqueKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("PrimaryVersionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProductionLocations")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ProductionYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("RunTimeTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("SeasonId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeasonName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("SeriesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesPresentationUniqueKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ShowId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("Size")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("StartDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Studios")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("TopParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TotalBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UnratedType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name");
+
+                    b.HasIndex("OwnerId");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("Path");
+
+                    b.HasIndex("PresentationUniqueKey");
+
+                    b.HasIndex("SeasonId");
+
+                    b.HasIndex("SeriesId");
+
+                    b.HasIndex("SeriesName");
+
+                    b.HasIndex("ExtraType", "OwnerId");
+
+                    b.HasIndex("TopParentId", "Id");
+
+                    b.HasIndex("Type", "TopParentId", "Id");
+
+                    b.HasIndex("Type", "TopParentId", "PresentationUniqueKey");
+
+                    b.HasIndex("Type", "TopParentId", "SortName");
+
+                    b.HasIndex("Type", "TopParentId", "StartDate");
+
+                    b.HasIndex("MediaType", "TopParentId", "IsVirtualItem", "PresentationUniqueKey");
+
+                    b.HasIndex("TopParentId", "IsFolder", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("TopParentId", "MediaType", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("TopParentId", "Type", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("Type", "SeriesPresentationUniqueKey", "IsFolder", "IsVirtualItem");
+
+                    b.HasIndex("Type", "SeriesPresentationUniqueKey", "ParentIndexNumber", "IndexNumber");
+
+                    b.HasIndex("Type", "SeriesPresentationUniqueKey", "PresentationUniqueKey", "SortName");
+
+                    b.HasIndex("IsFolder", "TopParentId", "IsVirtualItem", "PresentationUniqueKey", "DateCreated");
+
+                    b.HasIndex("Type", "TopParentId", "IsVirtualItem", "PresentationUniqueKey", "DateCreated");
+
+                    b.ToTable("BaseItems");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("00000000-0000-0000-0000-000000000001"),
+                            IsFolder = false,
+                            IsInMixedFolder = false,
+                            IsLocked = false,
+                            IsMovie = false,
+                            IsRepeat = false,
+                            IsSeries = false,
+                            IsVirtualItem = false,
+                            Name = "This is a placeholder item for UserData that has been detached from its original item",
+                            Type = "PLACEHOLDER"
+                        });
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemImageInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Blurhash")
+                        .HasColumnType("BLOB");
+
+                    b.Property<DateTime?>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ImageType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemId", "ImageType");
+
+                    b.ToTable("BaseItemImageInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemMetadataField", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("BaseItemMetadataFields");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemProvider", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderValue")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "ProviderId");
+
+                    b.HasIndex("ProviderId", "ItemId", "ProviderValue");
+
+                    b.ToTable("BaseItemProviders");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemTrailerType", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("BaseItemTrailerTypes");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Chapter", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChapterIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("ImageDateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ImagePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("StartPositionTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "ChapterIndex");
+
+                    b.ToTable("Chapters");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.CustomItemDisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "ItemId", "Client", "Key")
+                        .IsUnique();
+
+                    b.ToTable("CustomItemDisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChromecastVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DashboardTheme")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EnableNextVideoInfoOverlay")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("IndexBy")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ScrollDirection")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowBackdrop")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowSidebar")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SkipBackwardLength")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SkipForwardLength")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TvHome")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "ItemId", "Client")
+                        .IsUnique();
+
+                    b.ToTable("DisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.HomeSection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DisplayPreferencesId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DisplayPreferencesId");
+
+                    b.ToTable("HomeSection");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ImageInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("ImageInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemDisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("IndexBy")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RememberIndexing")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberSorting")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortBy")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ViewType")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("ItemDisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValue", b =>
+                {
+                    b.Property<Guid>("ItemValueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CleanValue")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemValueId");
+
+                    b.HasIndex("Type", "CleanValue");
+
+                    b.HasIndex("Type", "Value")
+                        .IsUnique();
+
+                    b.ToTable("ItemValues");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValueMap", b =>
+                {
+                    b.Property<Guid>("ItemValueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemValueId", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("ItemValuesMap");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.KeyframeData", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.PrimitiveCollection<string>("KeyframeTicks")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("TotalDuration")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId");
+
+                    b.ToTable("KeyframeData");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.LinkedChildEntity", b =>
+                {
+                    b.Property<Guid>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ChildId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChildType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ParentId", "ChildId");
+
+                    b.HasIndex("ChildId", "ChildType");
+
+                    b.HasIndex("ParentId", "ChildType");
+
+                    b.HasIndex("ParentId", "SortOrder");
+
+                    b.ToTable("LinkedChildren", (string)null);
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaSegment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("EndTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SegmentProviderId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("StartTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MediaSegments");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaStreamInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AspectRatio")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("AverageFrameRate")
+                        .HasColumnType("REAL");
+
+                    b.Property<int?>("BitDepth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("BitRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("BlPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ChannelLayout")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Channels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTimeBase")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorPrimaries")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorSpace")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorTransfer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DvBlSignalCompatibilityId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvLevel")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvProfile")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvVersionMajor")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvVersionMinor")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ElPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("Hdr10PlusPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsAnamorphic")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsAvc")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsExternal")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsForced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsHearingImpaired")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsInterlaced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("KeyFrames")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("Level")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("NalLengthSize")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PixelFormat")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Profile")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("RealFrameRate")
+                        .HasColumnType("REAL");
+
+                    b.Property<int?>("RefFrames")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Rotation")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RpuPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SampleRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StreamType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TimeBase")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "StreamIndex");
+
+                    b.ToTable("MediaStreamInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.People", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PersonType")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name");
+
+                    b.ToTable("Peoples");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.PeopleBaseItemMap", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("PeopleId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ListOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "PeopleId", "Role");
+
+                    b.HasIndex("PeopleId");
+
+                    b.HasIndex("ItemId", "ListOrder");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("PeopleBaseItemMap");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Permission", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("Permission_Permissions_Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Value")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "Kind")
+                        .IsUnique()
+                        .HasFilter("[UserId] IS NOT NULL");
+
+                    b.ToTable("Permissions");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("Preference_Preferences_Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(65535)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "Kind")
+                        .IsUnique()
+                        .HasFilter("[UserId] IS NOT NULL");
+
+                    b.ToTable("Preferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateLastActivity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccessToken")
+                        .IsUnique();
+
+                    b.ToTable("ApiKeys");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.Device", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AppName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AppVersion")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateLastActivity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccessToken", "DateLastActivity");
+
+                    b.HasIndex("DeviceId", "DateLastActivity");
+
+                    b.HasIndex("UserId", "DeviceId");
+
+                    b.ToTable("Devices");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.DeviceOptions", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CustomName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceId")
+                        .IsUnique();
+
+                    b.ToTable("DeviceOptions");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.TrickplayInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Bandwidth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Interval")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ThumbnailCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TileHeight")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TileWidth")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "Width");
+
+                    b.ToTable("TrickplayInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AudioLanguagePreference")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthenticationProviderId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CastReceiverId")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DisplayCollectionsView")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("DisplayMissingEpisodes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableAutoLogin")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableLocalPassword")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableNextEpisodeAutoPlay")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableUserPreferenceAccess")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("HidePlayedInLatest")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("InternalId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InvalidLoginAttemptCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastActivityDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastLoginDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("LoginAttemptsBeforeLockout")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxActiveSessions")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MaxParentalRatingScore")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MaxParentalRatingSubScore")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("MustUpdatePassword")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Password")
+                        .HasMaxLength(65535)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordResetProviderId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PlayDefaultAudioTrack")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberAudioSelections")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberSubtitleSelections")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RemoteClientBitrateLimit")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SubtitleLanguagePreference")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SyncPlayAccess")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.UserData", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CustomDataKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("AudioStreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsFavorite")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastPlayedDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool?>("Likes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("PlaybackPositionTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Played")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double?>("Rating")
+                        .HasColumnType("REAL");
+
+                    b.Property<DateTime?>("RetentionDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SubtitleStreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "UserId", "CustomDataKey");
+
+                    b.HasIndex("ItemId", "UserId", "IsFavorite");
+
+                    b.HasIndex("ItemId", "UserId", "LastPlayedDate");
+
+                    b.HasIndex("ItemId", "UserId", "PlaybackPositionTicks");
+
+                    b.HasIndex("ItemId", "UserId", "Played");
+
+                    b.HasIndex("UserId", "IsFavorite", "ItemId");
+
+                    b.HasIndex("UserId", "ItemId", "LastPlayedDate");
+
+                    b.HasIndex("UserId", "Played", "ItemId");
+
+                    b.ToTable("UserData");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("AccessSchedules")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AncestorId", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Parents")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "ParentItem")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("ParentItem");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AttachmentStreamInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Owner")
+                        .WithMany("Extras")
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "DirectParent")
+                        .WithMany("DirectChildren")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("DirectParent");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemImageInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Images")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemMetadataField", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("LockedFields")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemProvider", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Provider")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemTrailerType", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("TrailerTypes")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Chapter", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("DisplayPreferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.HomeSection", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.DisplayPreferences", null)
+                        .WithMany("HomeSections")
+                        .HasForeignKey("DisplayPreferencesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ImageInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithOne("ProfileImage")
+                        .HasForeignKey("Jellyfin.Database.Implementations.Entities.ImageInfo", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemDisplayPreferences", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("ItemDisplayPreferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValueMap", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("ItemValues")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.ItemValue", "ItemValue")
+                        .WithMany("BaseItemsMap")
+                        .HasForeignKey("ItemValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("ItemValue");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.KeyframeData", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.LinkedChildEntity", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Child")
+                        .WithMany("LinkedChildOfEntities")
+                        .HasForeignKey("ChildId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Parent")
+                        .WithMany("LinkedChildEntities")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Child");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaStreamInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("MediaStreams")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.PeopleBaseItemMap", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Peoples")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.People", "People")
+                        .WithMany("BaseItems")
+                        .HasForeignKey("PeopleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("People");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Permission", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("Permissions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Preference", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("Preferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.Device", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.UserData", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("UserData")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.Navigation("Chapters");
+
+                    b.Navigation("Children");
+
+                    b.Navigation("DirectChildren");
+
+                    b.Navigation("Extras");
+
+                    b.Navigation("Images");
+
+                    b.Navigation("ItemValues");
+
+                    b.Navigation("LinkedChildEntities");
+
+                    b.Navigation("LinkedChildOfEntities");
+
+                    b.Navigation("LockedFields");
+
+                    b.Navigation("MediaStreams");
+
+                    b.Navigation("Parents");
+
+                    b.Navigation("Peoples");
+
+                    b.Navigation("Provider");
+
+                    b.Navigation("TrailerTypes");
+
+                    b.Navigation("UserData");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.Navigation("HomeSections");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValue", b =>
+                {
+                    b.Navigation("BaseItemsMap");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.People", b =>
+                {
+                    b.Navigation("BaseItems");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.User", b =>
+                {
+                    b.Navigation("AccessSchedules");
+
+                    b.Navigation("DisplayPreferences");
+
+                    b.Navigation("ItemDisplayPreferences");
+
+                    b.Navigation("Permissions");
+
+                    b.Navigation("Preferences");
+
+                    b.Navigation("ProfileImage");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260215201634_ChangePrimaryVersionIdToGuid.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260215201634_ChangePrimaryVersionIdToGuid.cs
new file mode 100644
index 0000000000..6e7386e690
--- /dev/null
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260215201634_ChangePrimaryVersionIdToGuid.cs
@@ -0,0 +1,54 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Jellyfin.Database.Providers.Sqlite.Migrations
+{
+    /// <inheritdoc />
+    public partial class ChangePrimaryVersionIdToGuid : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Convert "N" format (32 chars, no hyphens) to standard GUID format (36 chars with hyphens)
+            migrationBuilder.Sql(
+                @"UPDATE BaseItems
+                  SET PrimaryVersionId = UPPER(
+                    SUBSTR(PrimaryVersionId,1,8)||'-'||
+                    SUBSTR(PrimaryVersionId,9,4)||'-'||
+                    SUBSTR(PrimaryVersionId,13,4)||'-'||
+                    SUBSTR(PrimaryVersionId,17,4)||'-'||
+                    SUBSTR(PrimaryVersionId,21,12))
+                  WHERE PrimaryVersionId IS NOT NULL AND LENGTH(PrimaryVersionId) = 32");
+
+            // Normalize existing standard-format values to uppercase
+            migrationBuilder.Sql(
+                @"UPDATE BaseItems
+                  SET PrimaryVersionId = UPPER(PrimaryVersionId)
+                  WHERE PrimaryVersionId IS NOT NULL");
+
+            // Clear invalid values (not 36 characters = not a valid GUID)
+            migrationBuilder.Sql(
+                @"UPDATE BaseItems
+                  SET PrimaryVersionId = NULL
+                  WHERE PrimaryVersionId IS NOT NULL AND LENGTH(PrimaryVersionId) != 36");
+
+            // Clear placeholder/empty GUIDs
+            migrationBuilder.Sql(
+                @"UPDATE BaseItems
+                  SET PrimaryVersionId = NULL
+                  WHERE PrimaryVersionId = '00000000-0000-0000-0000-000000000000'");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            // Convert standard GUID format back to "N" format (remove hyphens, lowercase)
+            migrationBuilder.Sql(
+                @"UPDATE BaseItems
+                  SET PrimaryVersionId = LOWER(REPLACE(PrimaryVersionId, '-', ''))
+                  WHERE PrimaryVersionId IS NOT NULL");
+        }
+    }
+}
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
index 912dc4efe8..17c6df4e9d 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
@@ -15,7 +15,7 @@ namespace Jellyfin.Server.Implementations.Migrations
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "10.0.2");
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.3");
 
             modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
                 {
@@ -294,7 +294,7 @@ namespace Jellyfin.Server.Implementations.Migrations
                     b.Property<string>("PresentationUniqueKey")
                         .HasColumnType("TEXT");
 
-                    b.Property<string>("PrimaryVersionId")
+                    b.Property<Guid?>("PrimaryVersionId")
                         .HasColumnType("TEXT");
 
                     b.Property<string>("ProductionLocations")
-- 
cgit v1.2.3


From ba356638e8e2d376e35a8e8774129662c9584865 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sun, 15 Feb 2026 23:13:01 +0100
Subject: Fix Extra refresh

---
 Emby.Server.Implementations/Library/LibraryManager.cs | 7 +++----
 MediaBrowser.Controller/Entities/BaseItem.cs          | 4 ++--
 2 files changed, 5 insertions(+), 6 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 7517dc03ba..9a5bd41914 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -3134,13 +3134,12 @@ namespace Emby.Server.Implementations.Library
                     extra.ExtraType = extraType;
                 }
 
-                // Only set OwnerId if this is actually an extra (not Unknown or null)
+                // Only return items that are actual extras (have ExtraType set)
+                // Note: OwnerId and ParentId are set by RefreshExtras, not here,
+                // so that RefreshExtras can detect when they need updating and set ForceSave.
                 if (extra.ExtraType is not null)
                 {
-                    extra.ParentId = Guid.Empty;
-                    extra.OwnerId = owner.Id;
                     extra.IsInMixedFolder = isInMixedFolder;
-
                     return extra;
                 }
 
diff --git a/MediaBrowser.Controller/Entities/BaseItem.cs b/MediaBrowser.Controller/Entities/BaseItem.cs
index 67b56ba5f0..e19074d0c9 100644
--- a/MediaBrowser.Controller/Entities/BaseItem.cs
+++ b/MediaBrowser.Controller/Entities/BaseItem.cs
@@ -1432,11 +1432,11 @@ namespace MediaBrowser.Controller.Entities
                 var subOptions = new MetadataRefreshOptions(options);
                 if (!i.OwnerId.Equals(ownerId) || !i.ParentId.IsEmpty())
                 {
-                    i.OwnerId = ownerId;
-                    i.ParentId = Guid.Empty;
                     subOptions.ForceSave = true;
                 }
 
+                i.OwnerId = ownerId;
+                i.ParentId = Guid.Empty;
                 return RefreshMetadataForOwnedItem(i, true, subOptions, cancellationToken);
             });
 
-- 
cgit v1.2.3


From 3a090a571682033f54cc2824d4003ff873467b4c Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Wed, 18 Feb 2026 20:28:42 +0100
Subject: Optimize item count calculation for named items

---
 Emby.Server.Implementations/Dto/DtoService.cs      |  32 +----
 .../Library/LibraryManager.cs                      |  12 ++
 Jellyfin.Api/Controllers/UserLibraryController.cs  |   4 +-
 .../Item/BaseItemRepository.cs                     | 135 +++++++++++++++++++++
 MediaBrowser.Controller/Library/ILibraryManager.cs |  10 ++
 .../Persistence/IItemRepository.cs                 |  11 ++
 6 files changed, 171 insertions(+), 33 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 626f4ed0cd..07938d172f 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -418,37 +418,7 @@ namespace Emby.Server.Implementations.Dto
                 return;
             }
 
-            var query = new InternalItemsQuery(user)
-            {
-                Recursive = true,
-                DtoOptions = new DtoOptions(false) { EnableImages = false },
-                IncludeItemTypes = relatedItemKinds
-            };
-
-            switch (dto.Type)
-            {
-                case BaseItemKind.Genre:
-                case BaseItemKind.MusicGenre:
-                    query.GenreIds = [dto.Id];
-                    break;
-                case BaseItemKind.MusicArtist:
-                    query.ArtistIds = [dto.Id];
-                    break;
-                case BaseItemKind.Person:
-                    query.PersonIds = [dto.Id];
-                    break;
-                case BaseItemKind.Studio:
-                    query.StudioIds = [dto.Id];
-                    break;
-                case BaseItemKind.Year
-                    when int.TryParse(dto.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var year):
-                    query.Years = [year];
-                    break;
-                default:
-                    return;
-            }
-
-            var counts = _libraryManager.GetItemCounts(query);
+            var counts = _libraryManager.GetItemCountsForNameItem(dto.Type, dto.Id, relatedItemKinds, user);
 
             dto.AlbumCount = counts.AlbumCount;
             dto.ArtistCount = counts.ArtistCount;
diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 9a5bd41914..60ac15ca97 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -1561,6 +1561,18 @@ namespace Emby.Server.Implementations.Library
             return _itemRepository.GetItemCounts(query);
         }
 
+        /// <inheritdoc/>
+        public ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, User? user)
+        {
+            var query = new InternalItemsQuery(user);
+            if (user is not null)
+            {
+                AddUserToQuery(query, user);
+            }
+
+            return _itemRepository.GetItemCountsForNameItem(kind, id, relatedItemKinds, query);
+        }
+
         public Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId)
         {
             return _itemRepository.GetChildCountBatch(parentIds, userId);
diff --git a/Jellyfin.Api/Controllers/UserLibraryController.cs b/Jellyfin.Api/Controllers/UserLibraryController.cs
index c778d3f448..b908f92be6 100644
--- a/Jellyfin.Api/Controllers/UserLibraryController.cs
+++ b/Jellyfin.Api/Controllers/UserLibraryController.cs
@@ -647,13 +647,13 @@ public class UserLibraryController : BaseJellyfinApiController
             var hasMetadata = !string.IsNullOrWhiteSpace(item.Overview) && item.HasImage(ImageType.Primary);
             var performFullRefresh = !hasMetadata && (DateTime.UtcNow - item.DateLastRefreshed).TotalDays >= 3;
 
-            if (!hasMetadata)
+            if (performFullRefresh)
             {
                 var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
                 {
                     MetadataRefreshMode = MetadataRefreshMode.FullRefresh,
                     ImageRefreshMode = MetadataRefreshMode.FullRefresh,
-                    ForceSave = performFullRefresh
+                    ForceSave = true
                 };
 
                 await item.RefreshMetadata(options, CancellationToken.None).ConfigureAwait(false);
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index ed5db0f934..e05f4c45dc 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -1343,6 +1343,141 @@ public sealed class BaseItemRepository
         return result;
     }
 
+    /// <inheritdoc />
+    public ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, InternalItemsQuery accessFilter)
+    {
+        using var context = _dbProvider.CreateDbContext();
+
+        // Look up the item's name/cleanname
+        var item = context.BaseItems.AsNoTracking()
+            .Where(e => e.Id == id)
+            .Select(e => new { e.Name, e.CleanName })
+            .FirstOrDefault();
+
+        if (item is null)
+        {
+            return new ItemCounts();
+        }
+
+        // Build the base query starting from the mapping table (flipped join order)
+        IQueryable<BaseItemEntity> baseQuery;
+        switch (kind)
+        {
+            case BaseItemKind.Person:
+                baseQuery = context.PeopleBaseItemMap
+                    .AsNoTracking()
+                    .Where(m => m.People.Name == item.Name)
+                    .Select(m => m.Item);
+                break;
+            case BaseItemKind.MusicArtist:
+                baseQuery = context.ItemValuesMap
+                    .AsNoTracking()
+                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
+                        && (ivm.ItemValue.Type == ItemValueType.Artist || ivm.ItemValue.Type == ItemValueType.AlbumArtist))
+                    .Select(ivm => ivm.Item);
+                break;
+            case BaseItemKind.Genre:
+            case BaseItemKind.MusicGenre:
+                baseQuery = context.ItemValuesMap
+                    .AsNoTracking()
+                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
+                        && ivm.ItemValue.Type == ItemValueType.Genre)
+                    .Select(ivm => ivm.Item);
+                break;
+            case BaseItemKind.Studio:
+                baseQuery = context.ItemValuesMap
+                    .AsNoTracking()
+                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
+                        && ivm.ItemValue.Type == ItemValueType.Studios)
+                    .Select(ivm => ivm.Item);
+                break;
+            case BaseItemKind.Year:
+                if (int.TryParse(item.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var year))
+                {
+                    baseQuery = context.BaseItems
+                        .AsNoTracking()
+                        .Where(e => e.ProductionYear == year);
+                }
+                else
+                {
+                    return new ItemCounts();
+                }
+
+                break;
+            default:
+                return new ItemCounts();
+        }
+
+        // Apply type filter
+        var typeNames = relatedItemKinds.Select(k => _itemTypeLookup.BaseItemKindNames[k]).ToArray();
+        baseQuery = baseQuery.Where(e => typeNames.Contains(e.Type));
+
+        // Apply access filtering (parental ratings, blocked/allowed tags, library access)
+        baseQuery = ApplyAccessFiltering(context, baseQuery, accessFilter);
+
+        // Group by type and count
+        var counts = baseQuery
+            .GroupBy(x => x.Type)
+            .Select(x => new { x.Key, Count = x.Count() })
+            .ToArray();
+
+        var lookup = _itemTypeLookup.BaseItemKindNames;
+        var result = new ItemCounts
+        {
+            ItemCount = counts.Sum(c => c.Count)
+        };
+
+        foreach (var count in counts)
+        {
+            if (string.Equals(count.Key, lookup[BaseItemKind.MusicAlbum], StringComparison.Ordinal))
+            {
+                result.AlbumCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicArtist], StringComparison.Ordinal))
+            {
+                result.ArtistCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Episode], StringComparison.Ordinal))
+            {
+                result.EpisodeCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Movie], StringComparison.Ordinal))
+            {
+                result.MovieCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicVideo], StringComparison.Ordinal))
+            {
+                result.MusicVideoCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.LiveTvProgram], StringComparison.Ordinal))
+            {
+                result.ProgramCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Series], StringComparison.Ordinal))
+            {
+                result.SeriesCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Audio], StringComparison.Ordinal))
+            {
+                result.SongCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Trailer], StringComparison.Ordinal))
+            {
+                result.TrailerCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.BoxSet], StringComparison.Ordinal))
+            {
+                result.BoxSetCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Book], StringComparison.Ordinal))
+            {
+                result.BookCount = count.Count;
+            }
+        }
+
+        return result;
+    }
+
 #pragma warning disable CA1307 // Specify StringComparison for clarity
     /// <summary>
     /// Gets the type.
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index e73dede1d4..5cfb940891 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -706,6 +706,16 @@ namespace MediaBrowser.Controller.Library
 
         ItemCounts GetItemCounts(InternalItemsQuery query);
 
+        /// <summary>
+        /// Gets item counts for a "by-name" item using an optimized query path.
+        /// </summary>
+        /// <param name="kind">The kind of the name item.</param>
+        /// <param name="id">The ID of the name item.</param>
+        /// <param name="relatedItemKinds">The item kinds to count.</param>
+        /// <param name="user">The user for access filtering.</param>
+        /// <returns>The item counts grouped by type.</returns>
+        ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, User? user);
+
         /// <summary>
         /// Batch-fetches child counts for multiple parent folders.
         /// Returns the count of immediate children (non-recursive) for each parent.
diff --git a/MediaBrowser.Controller/Persistence/IItemRepository.cs b/MediaBrowser.Controller/Persistence/IItemRepository.cs
index f1b27c52db..bcbbcc4785 100644
--- a/MediaBrowser.Controller/Persistence/IItemRepository.cs
+++ b/MediaBrowser.Controller/Persistence/IItemRepository.cs
@@ -112,6 +112,17 @@ public interface IItemRepository
 
     ItemCounts GetItemCounts(InternalItemsQuery filter);
 
+    /// <summary>
+    /// Gets item counts for a "by-name" item (Person, MusicArtist, Genre, MusicGenre, Studio, Year)
+    /// using an optimized query that starts from the mapping table instead of scanning all BaseItems.
+    /// </summary>
+    /// <param name="kind">The kind of the name item.</param>
+    /// <param name="id">The ID of the name item.</param>
+    /// <param name="relatedItemKinds">The item kinds to count.</param>
+    /// <param name="accessFilter">A pre-configured query with user access filtering settings.</param>
+    /// <returns>The item counts grouped by type.</returns>
+    ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, InternalItemsQuery accessFilter);
+
     QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetGenres(InternalItemsQuery filter);
 
     QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetMusicGenres(InternalItemsQuery filter);
-- 
cgit v1.2.3


From ea0641b659fd6a3290453d3d70d5d82e63eb397d Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Mon, 23 Feb 2026 09:05:43 +0100
Subject: Fix version promotion

---
 Emby.Server.Implementations/Library/LibraryManager.cs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 60ac15ca97..88d29b73c9 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -427,6 +427,17 @@ namespace Emby.Server.Implementations.Library
                     // Promote the first alternate version to be the new primary
                     var newPrimary = alternateVersions[0];
                     newPrimary.SetPrimaryVersionId(null);
+                    newPrimary.OwnerId = Guid.Empty;
+
+                    // Transfer alternate version arrays from old primary to new primary
+                    // so UpdateToRepositoryAsync creates correct LinkedChildren entries
+                    newPrimary.LocalAlternateVersions = video.LocalAlternateVersions
+                        .Where(p => !string.Equals(p, newPrimary.Path, StringComparison.OrdinalIgnoreCase))
+                        .ToArray();
+                    newPrimary.LinkedAlternateVersions = video.LinkedAlternateVersions
+                        .Where(lc => !lc.ItemId.HasValue || !lc.ItemId.Value.Equals(newPrimary.Id))
+                        .ToArray();
+
                     newPrimary.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
 
                     // Re-route playlist/collection references from deleted primary to new primary
@@ -436,6 +447,7 @@ namespace Emby.Server.Implementations.Library
                     foreach (var alternate in alternateVersions.Skip(1))
                     {
                         alternate.SetPrimaryVersionId(newPrimary.Id);
+                        alternate.OwnerId = newPrimary.Id;
                         alternate.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
                     }
                 }
-- 
cgit v1.2.3


From 34c1e45bc2e496e9589775576c0f0a99e9159a0c Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Mon, 23 Feb 2026 17:01:38 +0100
Subject: Fixup

---
 Emby.Server.Implementations/Library/LibraryManager.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 88d29b73c9..c0782c8f9b 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -447,7 +447,7 @@ namespace Emby.Server.Implementations.Library
                     foreach (var alternate in alternateVersions.Skip(1))
                     {
                         alternate.SetPrimaryVersionId(newPrimary.Id);
-                        alternate.OwnerId = newPrimary.Id;
+                        alternate.OwnerId = Guid.Empty;
                         alternate.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
                     }
                 }
-- 
cgit v1.2.3


From 2d0d497961a7ca990384bd180f381824d5591cb8 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Wed, 25 Feb 2026 21:03:46 +0100
Subject: Update saved metadata on primary change

---
 .../Library/LibraryManager.cs                      | 25 ++++++++++++++++++----
 Jellyfin.Api/Controllers/VideosController.cs       |  2 +-
 .../Item/BaseItemRepository.cs                     | 18 +++++++++++++---
 MediaBrowser.Controller/Entities/Folder.cs         |  2 +-
 MediaBrowser.Controller/Library/ILibraryManager.cs |  4 ++--
 .../Persistence/IItemRepository.cs                 |  4 ++--
 6 files changed, 42 insertions(+), 13 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index c0782c8f9b..144238e3e0 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -441,7 +441,7 @@ namespace Emby.Server.Implementations.Library
                     newPrimary.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
 
                     // Re-route playlist/collection references from deleted primary to new primary
-                    _itemRepository.RerouteLinkedChildren(video.Id, newPrimary.Id);
+                    RerouteLinkedChildReferencesAsync(video.Id, newPrimary.Id).GetAwaiter().GetResult();
 
                     // Update remaining alternates to point to new primary
                     foreach (var alternate in alternateVersions.Skip(1))
@@ -455,7 +455,7 @@ namespace Emby.Server.Implementations.Library
             else if (item is Video alternateVideo && alternateVideo.PrimaryVersionId.HasValue)
             {
                 // If deleting an alternate version, re-route references to its primary
-                _itemRepository.RerouteLinkedChildren(alternateVideo.Id, alternateVideo.PrimaryVersionId.Value);
+                RerouteLinkedChildReferencesAsync(alternateVideo.Id, alternateVideo.PrimaryVersionId.Value).GetAwaiter().GetResult();
             }
 
             var children = item.IsFolder
@@ -3655,9 +3655,26 @@ namespace Emby.Server.Implementations.Library
         }
 
         /// <inheritdoc />
-        public int RerouteLinkedChildReferences(Guid fromChildId, Guid toChildId)
+        public async Task RerouteLinkedChildReferencesAsync(Guid fromChildId, Guid toChildId)
         {
-            return _itemRepository.RerouteLinkedChildren(fromChildId, toChildId);
+            var affectedParentIds = _itemRepository.RerouteLinkedChildren(fromChildId, toChildId);
+
+            // Update in-memory LinkedChildren and re-save metadata (NFO) for affected parents
+            foreach (var parentId in affectedParentIds)
+            {
+                if (GetItemById(parentId) is Folder parent)
+                {
+                    foreach (var lc in parent.LinkedChildren)
+                    {
+                        if (lc.ItemId.HasValue && lc.ItemId.Value.Equals(fromChildId))
+                        {
+                            lc.ItemId = toChildId;
+                        }
+                    }
+
+                    await RunMetadataSavers(parent, ItemUpdateType.MetadataEdit).ConfigureAwait(false);
+                }
+            }
         }
 
         /// <inheritdoc />
diff --git a/Jellyfin.Api/Controllers/VideosController.cs b/Jellyfin.Api/Controllers/VideosController.cs
index 155871770a..2161391105 100644
--- a/Jellyfin.Api/Controllers/VideosController.cs
+++ b/Jellyfin.Api/Controllers/VideosController.cs
@@ -223,7 +223,7 @@ public class VideosController : BaseJellyfinApiController
             await item.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).ConfigureAwait(false);
 
             // Re-route any playlist/collection references from this item to the primary
-            _libraryManager.RerouteLinkedChildReferences(item.Id, primaryVersion.Id);
+            await _libraryManager.RerouteLinkedChildReferencesAsync(item.Id, primaryVersion.Id).ConfigureAwait(false);
 
             if (!alternateVersionsOfPrimary.Any(i => i.ItemId.HasValue && i.ItemId.Value.Equals(item.Id)))
             {
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index dea4e04108..6e80d38d7d 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -4439,10 +4439,22 @@ public sealed class BaseItemRepository
     }
 
     /// <inheritdoc/>
-    public int RerouteLinkedChildren(Guid fromChildId, Guid toChildId)
+    public IReadOnlyList<Guid> RerouteLinkedChildren(Guid fromChildId, Guid toChildId)
     {
         using var context = _dbProvider.CreateDbContext();
 
+        // Collect all affected parent IDs before modifying
+        var affectedParentIds = context.LinkedChildren
+            .Where(lc => lc.ChildId == fromChildId && lc.ChildType == DbLinkedChildType.Manual)
+            .Select(lc => lc.ParentId)
+            .Distinct()
+            .ToList();
+
+        if (affectedParentIds.Count == 0)
+        {
+            return affectedParentIds;
+        }
+
         // Get parents that already reference toChildId (to avoid duplicates)
         var parentsWithTarget = context.LinkedChildren
             .Where(lc => lc.ChildId == toChildId && lc.ChildType == DbLinkedChildType.Manual)
@@ -4450,7 +4462,7 @@ public sealed class BaseItemRepository
             .ToHashSet();
 
         // Update references that won't create duplicates
-        var updated = context.LinkedChildren
+        context.LinkedChildren
             .Where(lc => lc.ChildId == fromChildId
                 && lc.ChildType == DbLinkedChildType.Manual
                 && !parentsWithTarget.Contains(lc.ParentId))
@@ -4463,7 +4475,7 @@ public sealed class BaseItemRepository
                 && parentsWithTarget.Contains(lc.ParentId))
             .ExecuteDelete();
 
-        return updated;
+        return affectedParentIds;
     }
 
     /// <inheritdoc/>
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index 3428d1fc12..dce5664672 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -590,7 +590,7 @@ namespace MediaBrowser.Controller.Entities
                     await oldPrimary.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, cancellationToken).ConfigureAwait(false);
 
                     // Re-route playlist/collection references from old primary to new primary
-                    LibraryManager.RerouteLinkedChildReferences(oldPrimary.Id, newPrimary.Id);
+                    await LibraryManager.RerouteLinkedChildReferencesAsync(oldPrimary.Id, newPrimary.Id).ConfigureAwait(false);
                 }
 
                 // After removing items, reattach any detached user data to remaining children
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index 5cfb940891..bcabfff772 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -767,8 +767,8 @@ namespace MediaBrowser.Controller.Library
         /// </summary>
         /// <param name="fromChildId">The child ID to re-route from.</param>
         /// <param name="toChildId">The child ID to re-route to.</param>
-        /// <returns>Number of references updated.</returns>
-        int RerouteLinkedChildReferences(Guid fromChildId, Guid toChildId);
+        /// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
+        Task RerouteLinkedChildReferencesAsync(Guid fromChildId, Guid toChildId);
 
         /// <summary>
         /// Gets legacy query filters for filtering UI.
diff --git a/MediaBrowser.Controller/Persistence/IItemRepository.cs b/MediaBrowser.Controller/Persistence/IItemRepository.cs
index bcbbcc4785..52250b4058 100644
--- a/MediaBrowser.Controller/Persistence/IItemRepository.cs
+++ b/MediaBrowser.Controller/Persistence/IItemRepository.cs
@@ -254,8 +254,8 @@ public interface IItemRepository
     /// </summary>
     /// <param name="fromChildId">The child ID to re-route from.</param>
     /// <param name="toChildId">The child ID to re-route to.</param>
-    /// <returns>Number of references updated.</returns>
-    int RerouteLinkedChildren(Guid fromChildId, Guid toChildId);
+    /// <returns>List of parent item IDs whose LinkedChildren were modified.</returns>
+    IReadOnlyList<Guid> RerouteLinkedChildren(Guid fromChildId, Guid toChildId);
 
     /// <summary>
     /// Creates or updates a LinkedChild entry linking a parent to a child item.
-- 
cgit v1.2.3


From 885b45838cbcacb097e5981df7a93489da952fa6 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 27 Feb 2026 13:30:23 +0100
Subject: Enable Extras for BD and DVD folders

---
 Emby.Server.Implementations/Library/LibraryManager.cs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 144238e3e0..ef3402089b 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -3096,7 +3096,8 @@ namespace Emby.Server.Implementations.Library
         {
             // Apply .ignore rules
             var filtered = fileSystemChildren.Where(c => !DotIgnoreIgnoreRule.IsIgnored(c, owner)).ToList();
-            var ownerVideoInfo = VideoResolver.Resolve(owner.Path, owner.IsFolder, _namingOptions, libraryRoot: owner.ContainingFolderPath);
+            var isFolder = owner.IsFolder || (owner is Video video && (video.VideoType == VideoType.BluRay || video.VideoType == VideoType.Dvd));
+            var ownerVideoInfo = VideoResolver.Resolve(owner.Path, isFolder, _namingOptions, libraryRoot: owner.ContainingFolderPath);
             if (ownerVideoInfo is null)
             {
                 yield break;
-- 
cgit v1.2.3


From 826e21ecc85be03e15c4d2ad2f403ccb4dc2068e Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 27 Feb 2026 13:51:51 +0100
Subject: Fix LinkedAlternativeVersion validation

---
 Emby.Server.Implementations/Library/LibraryManager.cs | 9 +++++++++
 MediaBrowser.Controller/Entities/Folder.cs            | 7 -------
 2 files changed, 9 insertions(+), 7 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index ef3402089b..0ad63ef84a 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -456,6 +456,15 @@ namespace Emby.Server.Implementations.Library
             {
                 // If deleting an alternate version, re-route references to its primary
                 RerouteLinkedChildReferencesAsync(alternateVideo.Id, alternateVideo.PrimaryVersionId.Value).GetAwaiter().GetResult();
+
+                // Remove deleted alternate from primary's LinkedAlternateVersions
+                if (GetItemById(alternateVideo.PrimaryVersionId.Value) is Video primaryVideo)
+                {
+                    primaryVideo.LinkedAlternateVersions = primaryVideo.LinkedAlternateVersions
+                        .Where(lc => !lc.ItemId.HasValue || !lc.ItemId.Value.Equals(alternateVideo.Id))
+                        .ToArray();
+                    primaryVideo.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
+                }
             }
 
             var children = item.IsFolder
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index dce5664672..cc322d0ddd 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -510,13 +510,6 @@ namespace MediaBrowser.Controller.Entities
                         // Skip items that are alternate versions of another video
                         if (item is Video video)
                         {
-                            // Check via PrimaryVersionId
-                            if (video.PrimaryVersionId.HasValue)
-                            {
-                                Logger.LogDebug("Item is an alternate version (via PrimaryVersionId), skipping deletion: {Path}", item.Path ?? item.Name);
-                                continue;
-                            }
-
                             // Check if path is in LocalAlternateVersions of any valid child
                             if (!string.IsNullOrEmpty(item.Path) && alternateVersionPaths.Contains(item.Path))
                             {
-- 
cgit v1.2.3


From 46ffe0af9cc45f84ac91e09991e8b4fde62867ad Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 27 Feb 2026 20:07:09 +0100
Subject: Fix version promotion if multiple versions change

---
 Emby.Server.Implementations/Library/LibraryManager.cs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 0ad63ef84a..d4c03ecc75 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -410,7 +410,8 @@ namespace Emby.Server.Implementations.Library
             // OwnerId check: items with OwnerId set are alternate versions or extras, not primaries
             if (item is Video video && !video.PrimaryVersionId.HasValue && video.OwnerId.IsEmpty())
             {
-                var alternateVersions = GetLocalAlternateVersionIds(video)
+                var localAlternateIds = GetLocalAlternateVersionIds(video).ToHashSet();
+                var alternateVersions = localAlternateIds
                     .Concat(GetLinkedAlternateVersions(video).Select(v => v.Id))
                     .Distinct()
                     .Select(id => GetItemById(id))
@@ -447,7 +448,8 @@ namespace Emby.Server.Implementations.Library
                     foreach (var alternate in alternateVersions.Skip(1))
                     {
                         alternate.SetPrimaryVersionId(newPrimary.Id);
-                        alternate.OwnerId = Guid.Empty;
+                        // Only set OwnerId for local alternates; linked alternates are independent items
+                        alternate.OwnerId = localAlternateIds.Contains(alternate.Id) ? newPrimary.Id : Guid.Empty;
                         alternate.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
                     }
                 }
-- 
cgit v1.2.3


From 077fa89717957f871b172ca4b2dc4a178efd3bc5 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sat, 7 Mar 2026 20:12:42 +0100
Subject: Split BaseItemRepository and IItemRepository

---
 Emby.Server.Implementations/ApplicationHost.cs     |    9 +-
 .../Library/LibraryManager.cs                      |   56 +-
 .../ScheduledTasks/Tasks/AudioNormalizationTask.cs |   16 +-
 .../Item/BaseItemMapper.cs                         |  494 +++
 .../Item/BaseItemRepository.ByName.cs              |  293 ++
 .../Item/BaseItemRepository.QueryBuilding.cs       |  541 +++
 .../Item/BaseItemRepository.Querying.cs            |  553 +++
 .../Item/BaseItemRepository.TranslateQuery.cs      | 1118 +++++
 .../Item/BaseItemRepository.cs                     | 4419 +-------------------
 .../Item/ItemCountService.cs                       |  427 ++
 .../Item/ItemPersistenceService.cs                 |  637 +++
 .../Item/LinkedChildrenService.cs                  |  160 +
 .../Item/NextUpService.cs                          |  345 ++
 .../Migrations/Routines/CleanupOrphanedExtras.cs   |    3 +
 .../Migrations/Routines/FixAudioData.cs            |   19 +-
 .../Routines/FixIncorrectOwnerIdRelationships.cs   |   10 +-
 MediaBrowser.Controller/Entities/BaseItem.cs       |    2 +
 MediaBrowser.Controller/Entities/Folder.cs         |    4 +-
 .../Persistence/IItemCountService.cs               |   86 +
 .../Persistence/IItemPersistenceService.cs         |   47 +
 .../Persistence/IItemQueryHelpers.cs               |   94 +
 .../Persistence/IItemRepository.cs                 |  211 +-
 .../Persistence/ILinkedChildrenService.cs          |   50 +
 .../Persistence/INextUpService.cs                  |   33 +
 24 files changed, 5083 insertions(+), 4544 deletions(-)
 create mode 100644 Jellyfin.Server.Implementations/Item/BaseItemMapper.cs
 create mode 100644 Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs
 create mode 100644 Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs
 create mode 100644 Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs
 create mode 100644 Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
 create mode 100644 Jellyfin.Server.Implementations/Item/ItemCountService.cs
 create mode 100644 Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
 create mode 100644 Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
 create mode 100644 Jellyfin.Server.Implementations/Item/NextUpService.cs
 create mode 100644 MediaBrowser.Controller/Persistence/IItemCountService.cs
 create mode 100644 MediaBrowser.Controller/Persistence/IItemPersistenceService.cs
 create mode 100644 MediaBrowser.Controller/Persistence/IItemQueryHelpers.cs
 create mode 100644 MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
 create mode 100644 MediaBrowser.Controller/Persistence/INextUpService.cs

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/ApplicationHost.cs b/Emby.Server.Implementations/ApplicationHost.cs
index cbb0f6c565..e8cab6ea8c 100644
--- a/Emby.Server.Implementations/ApplicationHost.cs
+++ b/Emby.Server.Implementations/ApplicationHost.cs
@@ -507,7 +507,13 @@ namespace Emby.Server.Implementations
 
             serviceCollection.AddSingleton<IUserDataManager, UserDataManager>();
 
-            serviceCollection.AddSingleton<IItemRepository, BaseItemRepository>();
+            serviceCollection.AddSingleton<BaseItemRepository>();
+            serviceCollection.AddSingleton<IItemRepository>(sp => sp.GetRequiredService<BaseItemRepository>());
+            serviceCollection.AddSingleton<IItemQueryHelpers>(sp => sp.GetRequiredService<BaseItemRepository>());
+            serviceCollection.AddSingleton<IItemPersistenceService, ItemPersistenceService>();
+            serviceCollection.AddSingleton<INextUpService, NextUpService>();
+            serviceCollection.AddSingleton<IItemCountService, ItemCountService>();
+            serviceCollection.AddSingleton<ILinkedChildrenService, LinkedChildrenService>();
             serviceCollection.AddSingleton<IPeopleRepository, PeopleRepository>();
             serviceCollection.AddSingleton<IChapterRepository, ChapterRepository>();
             serviceCollection.AddSingleton<IMediaAttachmentRepository, MediaAttachmentRepository>();
@@ -641,6 +647,7 @@ namespace Emby.Server.Implementations
             BaseItem.ConfigurationManager = ConfigurationManager;
             BaseItem.FileSystem = Resolve<IFileSystem>();
             BaseItem.ItemRepository = Resolve<IItemRepository>();
+            BaseItem.ItemCountService = Resolve<IItemCountService>();
             BaseItem.LibraryManager = Resolve<ILibraryManager>();
             BaseItem.LocalizationManager = Resolve<ILocalizationManager>();
             BaseItem.Logger = Resolve<ILogger<BaseItem>>();
diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index d4c03ecc75..8b715d3786 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -77,6 +77,10 @@ namespace Emby.Server.Implementations.Library
         private readonly IMediaEncoder _mediaEncoder;
         private readonly IFileSystem _fileSystem;
         private readonly IItemRepository _itemRepository;
+        private readonly IItemPersistenceService _persistenceService;
+        private readonly INextUpService _nextUpService;
+        private readonly IItemCountService _countService;
+        private readonly ILinkedChildrenService _linkedChildrenService;
         private readonly IImageProcessor _imageProcessor;
         private readonly NamingOptions _namingOptions;
         private readonly IPeopleRepository _peopleRepository;
@@ -115,6 +119,10 @@ namespace Emby.Server.Implementations.Library
         /// <param name="userViewManagerFactory">The user view manager.</param>
         /// <param name="mediaEncoder">The media encoder.</param>
         /// <param name="itemRepository">The item repository.</param>
+        /// <param name="persistenceService">The item persistence service.</param>
+        /// <param name="nextUpService">The next up service.</param>
+        /// <param name="countService">The item count service.</param>
+        /// <param name="linkedChildrenService">The linked children service.</param>
         /// <param name="imageProcessor">The image processor.</param>
         /// <param name="namingOptions">The naming options.</param>
         /// <param name="directoryService">The directory service.</param>
@@ -133,6 +141,10 @@ namespace Emby.Server.Implementations.Library
             Lazy<IUserViewManager> userViewManagerFactory,
             IMediaEncoder mediaEncoder,
             IItemRepository itemRepository,
+            IItemPersistenceService persistenceService,
+            INextUpService nextUpService,
+            IItemCountService countService,
+            ILinkedChildrenService linkedChildrenService,
             IImageProcessor imageProcessor,
             NamingOptions namingOptions,
             IDirectoryService directoryService,
@@ -151,6 +163,10 @@ namespace Emby.Server.Implementations.Library
             _userViewManagerFactory = userViewManagerFactory;
             _mediaEncoder = mediaEncoder;
             _itemRepository = itemRepository;
+            _persistenceService = persistenceService;
+            _nextUpService = nextUpService;
+            _countService = countService;
+            _linkedChildrenService = linkedChildrenService;
             _imageProcessor = imageProcessor;
 
             _cache = new FastConcurrentLru<Guid, BaseItem>(_configurationManager.Configuration.CacheSize);
@@ -363,7 +379,7 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            _itemRepository.DeleteItem([.. pathMaps.Select(f => f.Item.Id)]);
+            _persistenceService.DeleteItem([.. pathMaps.Select(f => f.Item.Id)]);
         }
 
         public void DeleteItem(BaseItem item, DeleteOptions options, BaseItem parent, bool notifyParentItem)
@@ -513,7 +529,7 @@ namespace Emby.Server.Implementations.Library
 
             item.SetParent(null);
 
-            _itemRepository.DeleteItem([item.Id, .. children.Select(f => f.Id)]);
+            _persistenceService.DeleteItem([item.Id, .. children.Select(f => f.Id)]);
             _cache.TryRemove(item.Id, out _);
             foreach (var child in children)
             {
@@ -1158,7 +1174,7 @@ namespace Emby.Server.Implementations.Library
 
         public IReadOnlyDictionary<string, MusicArtist[]> GetArtists(IReadOnlyList<string> names)
         {
-            return _itemRepository.FindArtists(names);
+            return _linkedChildrenService.FindArtists(names);
         }
 
         public MusicArtist GetArtist(string name, DtoOptions options)
@@ -1303,7 +1319,7 @@ namespace Emby.Server.Implementations.Library
 
             if (toDelete.Count > 0)
             {
-                _itemRepository.DeleteItem(toDelete.ToArray());
+                _persistenceService.DeleteItem(toDelete.ToArray());
             }
         }
 
@@ -1379,7 +1395,7 @@ namespace Emby.Server.Implementations.Library
                 progress.Report(percent * 100);
             }
 
-            _itemRepository.UpdateInheritedValues();
+            _persistenceService.UpdateInheritedValues();
 
             progress.Report(100);
         }
@@ -1562,7 +1578,7 @@ namespace Emby.Server.Implementations.Library
                 AddUserToQuery(query, query.User);
             }
 
-            return _itemRepository.GetCount(query);
+            return _countService.GetCount(query);
         }
 
         public ItemCounts GetItemCounts(InternalItemsQuery query)
@@ -1581,7 +1597,7 @@ namespace Emby.Server.Implementations.Library
                 AddUserToQuery(query, query.User);
             }
 
-            return _itemRepository.GetItemCounts(query);
+            return _countService.GetItemCounts(query);
         }
 
         /// <inheritdoc/>
@@ -1593,18 +1609,18 @@ namespace Emby.Server.Implementations.Library
                 AddUserToQuery(query, user);
             }
 
-            return _itemRepository.GetItemCountsForNameItem(kind, id, relatedItemKinds, query);
+            return _countService.GetItemCountsForNameItem(kind, id, relatedItemKinds, query);
         }
 
         public Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId)
         {
-            return _itemRepository.GetChildCountBatch(parentIds, userId);
+            return _countService.GetChildCountBatch(parentIds, userId);
         }
 
         /// <inheritdoc/>
         public Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user)
         {
-            return _itemRepository.GetPlayedAndTotalCountBatch(folderIds, user);
+            return _countService.GetPlayedAndTotalCountBatch(folderIds, user);
         }
 
         public IReadOnlyList<BaseItem> GetItemList(InternalItemsQuery query, List<BaseItem> parents)
@@ -1649,7 +1665,7 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            return _itemRepository.GetNextUpSeriesKeys(query, dateCutoff);
+            return _nextUpService.GetNextUpSeriesKeys(query, dateCutoff);
         }
 
         /// <inheritdoc />
@@ -1659,7 +1675,7 @@ namespace Emby.Server.Implementations.Library
             bool includeSpecials,
             bool includeWatchedForRewatching)
         {
-            return _itemRepository.GetNextUpEpisodesBatch(query, seriesKeys, includeSpecials, includeWatchedForRewatching);
+            return _nextUpService.GetNextUpEpisodesBatch(query, seriesKeys, includeSpecials, includeWatchedForRewatching);
         }
 
         public QueryResult<BaseItem> QueryItems(InternalItemsQuery query)
@@ -2051,7 +2067,7 @@ namespace Emby.Server.Implementations.Library
         {
             ArgumentNullException.ThrowIfNull(video);
 
-            var linkedIds = _itemRepository.GetLinkedChildrenIds(video.Id, (int)MediaBrowser.Controller.Entities.LinkedChildType.LocalAlternateVersion);
+            var linkedIds = _linkedChildrenService.GetLinkedChildrenIds(video.Id, (int)MediaBrowser.Controller.Entities.LinkedChildType.LocalAlternateVersion);
             if (linkedIds.Count > 0)
             {
                 return linkedIds;
@@ -2065,7 +2081,7 @@ namespace Emby.Server.Implementations.Library
         {
             ArgumentNullException.ThrowIfNull(video);
 
-            var linkedIds = _itemRepository.GetLinkedChildrenIds(video.Id, (int)MediaBrowser.Controller.Entities.LinkedChildType.LinkedAlternateVersion);
+            var linkedIds = _linkedChildrenService.GetLinkedChildrenIds(video.Id, (int)MediaBrowser.Controller.Entities.LinkedChildType.LinkedAlternateVersion);
             if (linkedIds.Count > 0)
             {
                 return linkedIds
@@ -2081,7 +2097,7 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public void UpsertLinkedChild(Guid parentId, Guid childId, MediaBrowser.Controller.Entities.LinkedChildType childType)
         {
-            _itemRepository.UpsertLinkedChild(parentId, childId, childType);
+            _linkedChildrenService.UpsertLinkedChild(parentId, childId, childType);
         }
 
         /// <inheritdoc />
@@ -2223,7 +2239,7 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            _itemRepository.SaveItems(allItems, cancellationToken);
+            _persistenceService.SaveItems(allItems, cancellationToken);
 
             foreach (var item in allItems)
             {
@@ -2374,7 +2390,7 @@ namespace Emby.Server.Implementations.Library
 
             item.ValidateImages();
 
-            await _itemRepository.SaveImagesAsync(item).ConfigureAwait(false);
+            await _persistenceService.SaveImagesAsync(item).ConfigureAwait(false);
 
             RegisterItem(item);
         }
@@ -2426,7 +2442,7 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            _itemRepository.SaveItems(allItems, cancellationToken);
+            _persistenceService.SaveItems(allItems, cancellationToken);
 
             foreach (var item in allItems)
             {
@@ -2478,7 +2494,7 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public async Task ReattachUserDataAsync(BaseItem item, CancellationToken cancellationToken)
         {
-            await _itemRepository.ReattachUserDataAsync(item, cancellationToken).ConfigureAwait(false);
+            await _persistenceService.ReattachUserDataAsync(item, cancellationToken).ConfigureAwait(false);
         }
 
         public async Task RunMetadataSavers(BaseItem item, ItemUpdateType updateReason)
@@ -3669,7 +3685,7 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public async Task RerouteLinkedChildReferencesAsync(Guid fromChildId, Guid toChildId)
         {
-            var affectedParentIds = _itemRepository.RerouteLinkedChildren(fromChildId, toChildId);
+            var affectedParentIds = _linkedChildrenService.RerouteLinkedChildren(fromChildId, toChildId);
 
             // Update in-memory LinkedChildren and re-save metadata (NFO) for affected parents
             foreach (var parentId in affectedParentIds)
diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/AudioNormalizationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/AudioNormalizationTask.cs
index 36708e2582..b2dc89be28 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/AudioNormalizationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/AudioNormalizationTask.cs
@@ -26,7 +26,7 @@ namespace Emby.Server.Implementations.ScheduledTasks.Tasks;
 /// </summary>
 public partial class AudioNormalizationTask : IScheduledTask
 {
-    private readonly IItemRepository _itemRepository;
+    private readonly IItemPersistenceService _persistenceService;
     private readonly ILibraryManager _libraryManager;
     private readonly IMediaEncoder _mediaEncoder;
     private readonly IApplicationPaths _applicationPaths;
@@ -38,21 +38,21 @@ public partial class AudioNormalizationTask : IScheduledTask
     /// <summary>
     /// Initializes a new instance of the <see cref="AudioNormalizationTask"/> class.
     /// </summary>
-    /// <param name="itemRepository">Instance of the <see cref="IItemRepository"/> interface.</param>
+    /// <param name="persistenceService">Instance of the <see cref="IItemPersistenceService"/> interface.</param>
     /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
     /// <param name="mediaEncoder">Instance of the <see cref="IMediaEncoder"/> interface.</param>
     /// <param name="applicationPaths">Instance of the <see cref="IApplicationPaths"/> interface.</param>
     /// <param name="localizationManager">Instance of the <see cref="ILocalizationManager"/> interface.</param>
     /// <param name="logger">Instance of the <see cref="ILogger{AudioNormalizationTask}"/> interface.</param>
     public AudioNormalizationTask(
-        IItemRepository itemRepository,
+        IItemPersistenceService persistenceService,
         ILibraryManager libraryManager,
         IMediaEncoder mediaEncoder,
         IApplicationPaths applicationPaths,
         ILocalizationManager localizationManager,
         ILogger<AudioNormalizationTask> logger)
     {
-        _itemRepository = itemRepository;
+        _persistenceService = persistenceService;
         _libraryManager = libraryManager;
         _mediaEncoder = mediaEncoder;
         _applicationPaths = applicationPaths;
@@ -138,7 +138,7 @@ public partial class AudioNormalizationTask : IScheduledTask
                 {
                     if (toSaveDbItems.Count > 1)
                     {
-                        _itemRepository.SaveItems(toSaveDbItems, cancellationToken);
+                        _persistenceService.SaveItems(toSaveDbItems, cancellationToken);
                         toSaveDbItems.Clear();
                     }
 
@@ -158,7 +158,7 @@ public partial class AudioNormalizationTask : IScheduledTask
 
             if (toSaveDbItems.Count > 1)
             {
-                _itemRepository.SaveItems(toSaveDbItems, cancellationToken);
+                _persistenceService.SaveItems(toSaveDbItems, cancellationToken);
                 toSaveDbItems.Clear();
             }
 
@@ -183,7 +183,7 @@ public partial class AudioNormalizationTask : IScheduledTask
                 {
                     if (toSaveDbItems.Count > 1)
                     {
-                        _itemRepository.SaveItems(toSaveDbItems, cancellationToken);
+                        _persistenceService.SaveItems(toSaveDbItems, cancellationToken);
                         toSaveDbItems.Clear();
                     }
 
@@ -200,7 +200,7 @@ public partial class AudioNormalizationTask : IScheduledTask
 
             if (toSaveDbItems.Count > 1)
             {
-                _itemRepository.SaveItems(toSaveDbItems, cancellationToken);
+                _persistenceService.SaveItems(toSaveDbItems, cancellationToken);
             }
 
             // Update progress
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemMapper.cs b/Jellyfin.Server.Implementations/Item/BaseItemMapper.cs
new file mode 100644
index 0000000000..a879b07161
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/BaseItemMapper.cs
@@ -0,0 +1,494 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
+using System;
+using System.Collections.Concurrent;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using System.Text.Json;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Common;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.LiveTv;
+using Microsoft.Extensions.Logging;
+using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;
+using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+/// <summary>
+/// Handles mapping between BaseItemEntity (database) and BaseItemDto (domain) objects.
+/// </summary>
+internal static class BaseItemMapper
+{
+    /// <summary>
+    /// This holds all the types in the running assemblies
+    /// so that we can de-serialize properly when we don't have strong types.
+    /// </summary>
+    private static readonly ConcurrentDictionary<string, Type?> _typeMap = new ConcurrentDictionary<string, Type?>();
+
+    /// <summary>
+    /// Maps a Entity to the DTO.
+    /// </summary>
+    /// <param name="entity">The entity.</param>
+    /// <param name="dto">The dto base instance.</param>
+    /// <param name="appHost">The Application server Host.</param>
+    /// <returns>The dto to map.</returns>
+    public static BaseItemDto Map(BaseItemEntity entity, BaseItemDto dto, IServerApplicationHost? appHost)
+    {
+        dto.Id = entity.Id;
+        dto.ParentId = entity.ParentId.GetValueOrDefault();
+        dto.Path = appHost?.ExpandVirtualPath(entity.Path) ?? entity.Path;
+        dto.EndDate = entity.EndDate;
+        dto.CommunityRating = entity.CommunityRating;
+        dto.CustomRating = entity.CustomRating;
+        dto.IndexNumber = entity.IndexNumber;
+        dto.IsLocked = entity.IsLocked;
+        dto.Name = entity.Name;
+        dto.OfficialRating = entity.OfficialRating;
+        dto.Overview = entity.Overview;
+        dto.ParentIndexNumber = entity.ParentIndexNumber;
+        dto.PremiereDate = entity.PremiereDate;
+        dto.ProductionYear = entity.ProductionYear;
+        dto.SortName = entity.SortName;
+        dto.ForcedSortName = entity.ForcedSortName;
+        dto.RunTimeTicks = entity.RunTimeTicks;
+        dto.PreferredMetadataLanguage = entity.PreferredMetadataLanguage;
+        dto.PreferredMetadataCountryCode = entity.PreferredMetadataCountryCode;
+        dto.IsInMixedFolder = entity.IsInMixedFolder;
+        dto.InheritedParentalRatingValue = entity.InheritedParentalRatingValue;
+        dto.InheritedParentalRatingSubValue = entity.InheritedParentalRatingSubValue;
+        dto.CriticRating = entity.CriticRating;
+        dto.PresentationUniqueKey = entity.PresentationUniqueKey;
+        dto.OriginalTitle = entity.OriginalTitle;
+        dto.Album = entity.Album;
+        dto.LUFS = entity.LUFS;
+        dto.NormalizationGain = entity.NormalizationGain;
+        dto.IsVirtualItem = entity.IsVirtualItem;
+        dto.ExternalSeriesId = entity.ExternalSeriesId;
+        dto.Tagline = entity.Tagline;
+        dto.TotalBitrate = entity.TotalBitrate;
+        dto.ExternalId = entity.ExternalId;
+        dto.Size = entity.Size;
+        dto.Genres = string.IsNullOrWhiteSpace(entity.Genres) ? [] : entity.Genres.Split('|');
+        dto.DateCreated = entity.DateCreated ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
+        dto.DateModified = entity.DateModified ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
+        dto.ChannelId = entity.ChannelId ?? Guid.Empty;
+        dto.DateLastRefreshed = entity.DateLastRefreshed ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
+        dto.DateLastSaved = entity.DateLastSaved ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
+        dto.OwnerId = entity.OwnerId ?? Guid.Empty;
+        dto.Width = entity.Width.GetValueOrDefault();
+        dto.Height = entity.Height.GetValueOrDefault();
+        dto.UserData = entity.UserData;
+
+        if (entity.Provider is not null)
+        {
+            dto.ProviderIds = entity.Provider.ToDictionary(e => e.ProviderId, e => e.ProviderValue);
+        }
+
+        if (entity.ExtraType is not null)
+        {
+            dto.ExtraType = (ExtraType)entity.ExtraType;
+        }
+
+        if (entity.LockedFields is not null)
+        {
+            dto.LockedFields = entity.LockedFields?.Select(e => (MetadataField)e.Id).ToArray() ?? [];
+        }
+
+        if (entity.Audio is not null)
+        {
+            dto.Audio = (ProgramAudio)entity.Audio;
+        }
+
+        dto.ProductionLocations = entity.ProductionLocations?.Split('|', StringSplitOptions.RemoveEmptyEntries) ?? [];
+        dto.Studios = entity.Studios?.Split('|') ?? [];
+        dto.Tags = string.IsNullOrWhiteSpace(entity.Tags) ? [] : entity.Tags.Split('|');
+
+        if (dto is IHasProgramAttributes hasProgramAttributes)
+        {
+            hasProgramAttributes.IsMovie = entity.IsMovie;
+            hasProgramAttributes.IsSeries = entity.IsSeries;
+            hasProgramAttributes.EpisodeTitle = entity.EpisodeTitle;
+            hasProgramAttributes.IsRepeat = entity.IsRepeat;
+        }
+
+        if (dto is LiveTvChannel liveTvChannel)
+        {
+            liveTvChannel.ServiceName = entity.ExternalServiceId;
+        }
+
+        if (dto is Trailer trailer)
+        {
+            trailer.TrailerTypes = entity.TrailerTypes?.Select(e => (TrailerType)e.Id).ToArray() ?? [];
+        }
+
+        if (dto is Video video)
+        {
+            video.PrimaryVersionId = entity.PrimaryVersionId;
+        }
+
+        if (dto is IHasSeries hasSeriesName)
+        {
+            hasSeriesName.SeriesName = entity.SeriesName;
+            hasSeriesName.SeriesId = entity.SeriesId.GetValueOrDefault();
+            hasSeriesName.SeriesPresentationUniqueKey = entity.SeriesPresentationUniqueKey;
+        }
+
+        if (dto is Episode episode)
+        {
+            episode.SeasonName = entity.SeasonName;
+            episode.SeasonId = entity.SeasonId.GetValueOrDefault();
+        }
+
+        if (dto is IHasArtist hasArtists)
+        {
+            hasArtists.Artists = entity.Artists?.Split('|', StringSplitOptions.RemoveEmptyEntries) ?? [];
+        }
+
+        if (dto is IHasAlbumArtist hasAlbumArtists)
+        {
+            hasAlbumArtists.AlbumArtists = entity.AlbumArtists?.Split('|', StringSplitOptions.RemoveEmptyEntries) ?? [];
+        }
+
+        if (dto is LiveTvProgram program)
+        {
+            program.ShowId = entity.ShowId;
+        }
+
+        if (entity.Images is not null)
+        {
+            dto.ImageInfos = entity.Images.Select(e => MapImageFromEntity(e, appHost)).ToArray();
+        }
+
+        // dto.Type = entity.Type;
+        // dto.Data = entity.Data;
+        // dto.MediaType = Enum.TryParse<MediaType>(entity.MediaType);
+        if (dto is IHasStartDate hasStartDate)
+        {
+            hasStartDate.StartDate = entity.StartDate.GetValueOrDefault();
+        }
+
+        // Fields that are present in the DB but are never actually used
+        // dto.UnratedType = entity.UnratedType;
+        // dto.TopParentId = entity.TopParentId;
+        // dto.CleanName = entity.CleanName;
+        // dto.UserDataKey = entity.UserDataKey;
+
+        if (dto is Folder folder)
+        {
+            folder.DateLastMediaAdded = entity.DateLastMediaAdded ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
+            if (entity.LinkedChildEntities is not null && entity.LinkedChildEntities.Count > 0)
+            {
+                folder.LinkedChildren = entity.LinkedChildEntities
+                    .OrderBy(e => e.SortOrder)
+                    .Select(e => new LinkedChild
+                    {
+                        ItemId = e.ChildId,
+                        Type = (MediaBrowser.Controller.Entities.LinkedChildType)e.ChildType
+                    })
+                    .ToArray();
+            }
+        }
+
+        return dto;
+    }
+
+    /// <summary>
+    /// Maps a DTO to a database entity.
+    /// </summary>
+    /// <param name="dto">The DTO.</param>
+    /// <param name="appHost">The application host for path resolution.</param>
+    /// <returns>The database entity.</returns>
+    public static BaseItemEntity Map(BaseItemDto dto, IServerApplicationHost appHost)
+    {
+        var dtoType = dto.GetType();
+        var entity = new BaseItemEntity()
+        {
+            Type = dtoType.ToString(),
+            Id = dto.Id
+        };
+
+        if (TypeRequiresDeserialization(dtoType))
+        {
+            entity.Data = JsonSerializer.Serialize(dto, dtoType, JsonDefaults.Options);
+        }
+
+        entity.ParentId = !dto.ParentId.IsEmpty() ? dto.ParentId : null;
+        entity.Path = GetPathToSave(dto.Path, appHost);
+        entity.EndDate = dto.EndDate;
+        entity.CommunityRating = dto.CommunityRating;
+        entity.CustomRating = dto.CustomRating;
+        entity.IndexNumber = dto.IndexNumber;
+        entity.IsLocked = dto.IsLocked;
+        entity.Name = dto.Name;
+        entity.CleanName = dto.Name.GetCleanValue();
+        entity.OfficialRating = dto.OfficialRating;
+        entity.Overview = dto.Overview;
+        entity.ParentIndexNumber = dto.ParentIndexNumber;
+        entity.PremiereDate = dto.PremiereDate;
+        entity.ProductionYear = dto.ProductionYear;
+        entity.SortName = dto.SortName;
+        entity.ForcedSortName = dto.ForcedSortName;
+        entity.RunTimeTicks = dto.RunTimeTicks;
+        entity.PreferredMetadataLanguage = dto.PreferredMetadataLanguage;
+        entity.PreferredMetadataCountryCode = dto.PreferredMetadataCountryCode;
+        entity.IsInMixedFolder = dto.IsInMixedFolder;
+        entity.InheritedParentalRatingValue = dto.InheritedParentalRatingValue;
+        entity.InheritedParentalRatingSubValue = dto.InheritedParentalRatingSubValue;
+        entity.CriticRating = dto.CriticRating;
+        entity.PresentationUniqueKey = dto.PresentationUniqueKey;
+        entity.OriginalTitle = dto.OriginalTitle;
+        entity.Album = dto.Album;
+        entity.LUFS = dto.LUFS;
+        entity.NormalizationGain = dto.NormalizationGain;
+        entity.IsVirtualItem = dto.IsVirtualItem;
+        entity.ExternalSeriesId = dto.ExternalSeriesId;
+        entity.Tagline = dto.Tagline;
+        entity.TotalBitrate = dto.TotalBitrate;
+        entity.ExternalId = dto.ExternalId;
+        entity.Size = dto.Size;
+        entity.Genres = string.Join('|', dto.Genres);
+        entity.DateCreated = dto.DateCreated == DateTime.MinValue ? null : dto.DateCreated;
+        entity.DateModified = dto.DateModified == DateTime.MinValue ? null : dto.DateModified;
+        entity.ChannelId = dto.ChannelId;
+        entity.DateLastRefreshed = dto.DateLastRefreshed == DateTime.MinValue ? null : dto.DateLastRefreshed;
+        entity.DateLastSaved = dto.DateLastSaved == DateTime.MinValue ? null : dto.DateLastSaved;
+        entity.OwnerId = dto.OwnerId == Guid.Empty ? null : dto.OwnerId;
+        entity.Width = dto.Width;
+        entity.Height = dto.Height;
+        entity.Provider = dto.ProviderIds.Select(e => new BaseItemProvider()
+        {
+            Item = entity,
+            ProviderId = e.Key,
+            ProviderValue = e.Value
+        }).ToList();
+
+        if (dto.Audio.HasValue)
+        {
+            entity.Audio = (ProgramAudioEntity)dto.Audio;
+        }
+
+        if (dto.ExtraType.HasValue)
+        {
+            entity.ExtraType = (BaseItemExtraType)dto.ExtraType;
+        }
+
+        entity.ProductionLocations = dto.ProductionLocations is not null ? string.Join('|', dto.ProductionLocations.Where(p => !string.IsNullOrWhiteSpace(p))) : null;
+        entity.Studios = dto.Studios is not null ? string.Join('|', dto.Studios) : null;
+        entity.Tags = dto.Tags is not null ? string.Join('|', dto.Tags) : null;
+        entity.LockedFields = dto.LockedFields is not null ? dto.LockedFields
+            .Select(e => new BaseItemMetadataField()
+            {
+                Id = (int)e,
+                Item = entity,
+                ItemId = entity.Id
+            })
+            .ToArray() : null;
+
+        if (dto is IHasProgramAttributes hasProgramAttributes)
+        {
+            entity.IsMovie = hasProgramAttributes.IsMovie;
+            entity.IsSeries = hasProgramAttributes.IsSeries;
+            entity.EpisodeTitle = hasProgramAttributes.EpisodeTitle;
+            entity.IsRepeat = hasProgramAttributes.IsRepeat;
+        }
+
+        if (dto is LiveTvChannel liveTvChannel)
+        {
+            entity.ExternalServiceId = liveTvChannel.ServiceName;
+        }
+
+        if (dto is Video video)
+        {
+            entity.PrimaryVersionId = video.PrimaryVersionId;
+        }
+
+        if (dto is IHasSeries hasSeriesName)
+        {
+            entity.SeriesName = hasSeriesName.SeriesName;
+            entity.SeriesId = hasSeriesName.SeriesId;
+            entity.SeriesPresentationUniqueKey = hasSeriesName.SeriesPresentationUniqueKey;
+        }
+
+        if (dto is Episode episode)
+        {
+            entity.SeasonName = episode.SeasonName;
+            entity.SeasonId = episode.SeasonId;
+        }
+
+        if (dto is IHasArtist hasArtists)
+        {
+            entity.Artists = hasArtists.Artists is not null ? string.Join('|', hasArtists.Artists) : null;
+        }
+
+        if (dto is IHasAlbumArtist hasAlbumArtists)
+        {
+            entity.AlbumArtists = hasAlbumArtists.AlbumArtists is not null ? string.Join('|', hasAlbumArtists.AlbumArtists) : null;
+        }
+
+        if (dto is LiveTvProgram program)
+        {
+            entity.ShowId = program.ShowId;
+        }
+
+        if (dto.ImageInfos is not null)
+        {
+            entity.Images = dto.ImageInfos.Select(f => MapImageToEntity(dto.Id, f)).ToArray();
+        }
+
+        if (dto is Trailer trailer)
+        {
+            entity.TrailerTypes = trailer.TrailerTypes?.Select(e => new BaseItemTrailerType()
+            {
+                Id = (int)e,
+                Item = entity,
+                ItemId = entity.Id
+            }).ToArray() ?? [];
+        }
+
+        // dto.Type = entity.Type;
+        // dto.Data = entity.Data;
+        entity.MediaType = dto.MediaType.ToString();
+        if (dto is IHasStartDate hasStartDate)
+        {
+            entity.StartDate = hasStartDate.StartDate;
+        }
+
+        entity.UnratedType = dto.GetBlockUnratedType().ToString();
+
+        // Fields that are present in the DB but are never actually used
+        // dto.UserDataKey = entity.UserDataKey;
+
+        if (dto is Folder folder)
+        {
+            entity.DateLastMediaAdded = folder.DateLastMediaAdded == DateTime.MinValue ? null : folder.DateLastMediaAdded;
+            entity.IsFolder = folder.IsFolder;
+        }
+
+        return entity;
+    }
+
+    /// <summary>
+    /// Maps a database image entity to a domain image info.
+    /// </summary>
+    /// <param name="e">The database image entity.</param>
+    /// <param name="appHost">The application host.</param>
+    /// <returns>The mapped image info.</returns>
+    public static ItemImageInfo MapImageFromEntity(BaseItemImageInfo e, IServerApplicationHost? appHost)
+    {
+        return new ItemImageInfo()
+        {
+            Path = appHost?.ExpandVirtualPath(e.Path) ?? e.Path,
+            BlurHash = e.Blurhash is null ? null : Encoding.UTF8.GetString(e.Blurhash),
+            DateModified = e.DateModified ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc),
+            Height = e.Height,
+            Width = e.Width,
+            Type = (ImageType)e.ImageType
+        };
+    }
+
+    /// <summary>
+    /// Maps a domain image info to a database image entity.
+    /// </summary>
+    /// <param name="baseItemId">The parent item ID.</param>
+    /// <param name="e">The image info to map.</param>
+    /// <returns>The mapped database entity.</returns>
+    public static BaseItemImageInfo MapImageToEntity(Guid baseItemId, ItemImageInfo e)
+    {
+        return new BaseItemImageInfo()
+        {
+            ItemId = baseItemId,
+            Id = Guid.NewGuid(),
+            Path = e.Path,
+            Blurhash = e.BlurHash is null ? null : Encoding.UTF8.GetBytes(e.BlurHash),
+            DateModified = e.DateModified,
+            Height = e.Height,
+            Width = e.Width,
+            ImageType = (ImageInfoImageType)e.Type,
+            Item = null!
+        };
+    }
+
+    /// <summary>
+    /// Gets the type from a type name string.
+    /// </summary>
+    /// <param name="typeName">The type name.</param>
+    /// <returns>The resolved type, or null.</returns>
+    public static Type? GetType(string typeName)
+    {
+        ArgumentException.ThrowIfNullOrEmpty(typeName);
+
+        return _typeMap.GetOrAdd(typeName, k => AppDomain.CurrentDomain.GetAssemblies()
+            .Select(a => a.GetType(k))
+            .FirstOrDefault(t => t is not null));
+    }
+
+    /// <summary>
+    /// Checks whether a type requires JSON deserialization.
+    /// </summary>
+    /// <param name="type">The type to check.</param>
+    /// <returns>True if the type requires deserialization.</returns>
+    public static bool TypeRequiresDeserialization(Type type)
+    {
+        return type.GetCustomAttribute<RequiresSourceSerialisationAttribute>() == null;
+    }
+
+    /// <summary>
+    /// Deserializes a BaseItemEntity and sets all properties.
+    /// </summary>
+    /// <param name="baseItemEntity">The DB entity.</param>
+    /// <param name="logger">Logger.</param>
+    /// <param name="appHost">The application server Host.</param>
+    /// <param name="skipDeserialization">If only mapping should be processed.</param>
+    /// <returns>A mapped BaseItem, or null if the item type is unknown.</returns>
+    public static BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost? appHost, bool skipDeserialization = false)
+    {
+        var type = GetType(baseItemEntity.Type);
+        if (type is null)
+        {
+            logger.LogWarning(
+                "Skipping item {ItemId} with unknown type '{ItemType}'. This may indicate a removed plugin or database corruption.",
+                baseItemEntity.Id,
+                baseItemEntity.Type);
+            return null;
+        }
+
+        BaseItemDto? dto = null;
+        if (TypeRequiresDeserialization(type) && baseItemEntity.Data is not null && !skipDeserialization)
+        {
+            try
+            {
+                dto = JsonSerializer.Deserialize(baseItemEntity.Data, type, JsonDefaults.Options) as BaseItemDto;
+            }
+            catch (JsonException ex)
+            {
+                logger.LogError(ex, "Error deserializing item with JSON: {Data}", baseItemEntity.Data);
+            }
+        }
+
+        if (dto is null)
+        {
+            dto = Activator.CreateInstance(type) as BaseItemDto ?? throw new InvalidOperationException("Cannot deserialize unknown type.");
+        }
+
+        return Map(baseItemEntity, dto, appHost);
+    }
+
+    private static string? GetPathToSave(string path, IServerApplicationHost appHost)
+    {
+        if (path is null)
+        {
+            return null;
+        }
+
+        return appHost.ReverseVirtualPath(path);
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs
new file mode 100644
index 0000000000..0a8f8627b4
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs
@@ -0,0 +1,293 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Querying;
+using Microsoft.EntityFrameworkCore;
+using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+public sealed partial class BaseItemRepository
+{
+    /// <inheritdoc />
+    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAllArtists(InternalItemsQuery filter)
+    {
+        return GetItemValues(filter, _getAllArtistsValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);
+    }
+
+    /// <inheritdoc />
+    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetArtists(InternalItemsQuery filter)
+    {
+        return GetItemValues(filter, _getArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);
+    }
+
+    /// <inheritdoc />
+    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAlbumArtists(InternalItemsQuery filter)
+    {
+        return GetItemValues(filter, _getAlbumArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);
+    }
+
+    /// <inheritdoc />
+    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetStudios(InternalItemsQuery filter)
+    {
+        return GetItemValues(filter, _getStudiosValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]);
+    }
+
+    /// <inheritdoc />
+    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetGenres(InternalItemsQuery filter)
+    {
+        return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]);
+    }
+
+    /// <inheritdoc />
+    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetMusicGenres(InternalItemsQuery filter)
+    {
+        return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]);
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<string> GetStudioNames()
+    {
+        return GetItemValueNames(_getStudiosValueTypes, [], []);
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<string> GetAllArtistNames()
+    {
+        return GetItemValueNames(_getAllArtistsValueTypes, [], []);
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<string> GetMusicGenreNames()
+    {
+        return GetItemValueNames(
+            _getGenreValueTypes,
+            _itemTypeLookup.MusicGenreTypes,
+            []);
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<string> GetGenreNames()
+    {
+        return GetItemValueNames(
+            _getGenreValueTypes,
+            [],
+            _itemTypeLookup.MusicGenreTypes);
+    }
+
+    private string[] GetItemValueNames(IReadOnlyList<ItemValueType> itemValueTypes, IReadOnlyList<string> withItemTypes, IReadOnlyList<string> excludeItemTypes)
+    {
+        using var context = _dbProvider.CreateDbContext();
+
+        var query = context.ItemValuesMap
+            .AsNoTracking()
+            .Where(e => itemValueTypes.Any(w => w == e.ItemValue.Type));
+        if (withItemTypes.Count > 0)
+        {
+            query = query.Where(e => withItemTypes.Contains(e.Item.Type));
+        }
+
+        if (excludeItemTypes.Count > 0)
+        {
+            query = query.Where(e => !excludeItemTypes.Contains(e.Item.Type));
+        }
+
+        // query = query.DistinctBy(e => e.CleanValue);
+        return query.Select(e => e.ItemValue)
+            .GroupBy(e => e.CleanValue)
+            .Select(e => e.OrderBy(v => v.Value).First().Value)
+            .ToArray();
+    }
+
+    private QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetItemValues(InternalItemsQuery filter, IReadOnlyList<ItemValueType> itemValueTypes, string returnType)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+
+        if (!filter.Limit.HasValue)
+        {
+            filter.EnableTotalRecordCount = false;
+        }
+
+        using var context = _dbProvider.CreateDbContext();
+
+        var innerQueryFilter = TranslateQuery(context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)), context, new InternalItemsQuery(filter.User)
+        {
+            ExcludeItemTypes = filter.ExcludeItemTypes,
+            IncludeItemTypes = filter.IncludeItemTypes,
+            MediaTypes = filter.MediaTypes,
+            AncestorIds = filter.AncestorIds,
+            ItemIds = filter.ItemIds,
+            TopParentIds = filter.TopParentIds,
+            ParentId = filter.ParentId,
+            IsAiring = filter.IsAiring,
+            IsMovie = filter.IsMovie,
+            IsSports = filter.IsSports,
+            IsKids = filter.IsKids,
+            IsNews = filter.IsNews,
+            IsSeries = filter.IsSeries
+        });
+        var itemValuesQuery = context.ItemValuesMap
+            .Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))
+            .Join(
+                innerQueryFilter,
+                ivm => ivm.ItemId,
+                g => g.Id,
+                (ivm, g) => ivm.ItemValue.CleanValue);
+
+        var innerQuery = PrepareItemQuery(context, filter)
+            .Where(e => e.Type == returnType)
+            .Where(e => itemValuesQuery.Contains(e.CleanName));
+
+        var outerQueryFilter = new InternalItemsQuery(filter.User)
+        {
+            IsPlayed = filter.IsPlayed,
+            IsFavorite = filter.IsFavorite,
+            IsFavoriteOrLiked = filter.IsFavoriteOrLiked,
+            IsLiked = filter.IsLiked,
+            IsLocked = filter.IsLocked,
+            NameLessThan = filter.NameLessThan,
+            NameStartsWith = filter.NameStartsWith,
+            NameStartsWithOrGreater = filter.NameStartsWithOrGreater,
+            Tags = filter.Tags,
+            OfficialRatings = filter.OfficialRatings,
+            StudioIds = filter.StudioIds,
+            GenreIds = filter.GenreIds,
+            Genres = filter.Genres,
+            Years = filter.Years,
+            NameContains = filter.NameContains,
+            SearchTerm = filter.SearchTerm,
+            ExcludeItemIds = filter.ExcludeItemIds
+        };
+
+        var masterQuery = TranslateQuery(innerQuery, context, outerQueryFilter)
+            .GroupBy(e => e.PresentationUniqueKey)
+            .Select(e => e.OrderBy(x => x.Id).FirstOrDefault())
+            .Select(e => e!.Id);
+
+        var query = context.BaseItems
+            .Include(e => e.TrailerTypes)
+            .Include(e => e.Provider)
+            .Include(e => e.LockedFields)
+            .Include(e => e.Images)
+            .Include(e => e.LinkedChildEntities)
+            .AsSingleQuery()
+            .Where(e => masterQuery.Contains(e.Id));
+
+        query = ApplyOrder(query, filter, context);
+
+        var result = new QueryResult<(BaseItemDto, ItemCounts?)>();
+        if (filter.EnableTotalRecordCount)
+        {
+            result.TotalRecordCount = query.Count();
+        }
+
+        if (filter.Limit.HasValue || filter.StartIndex.HasValue)
+        {
+            var offset = filter.StartIndex ?? 0;
+
+            if (offset > 0)
+            {
+                query = query.Skip(offset);
+            }
+
+            if (filter.Limit.HasValue)
+            {
+                query = query.Take(filter.Limit.Value);
+            }
+        }
+
+        if (filter.IncludeItemTypes.Length > 0)
+        {
+            var typeSubQuery = new InternalItemsQuery(filter.User)
+            {
+                ExcludeItemTypes = filter.ExcludeItemTypes,
+                IncludeItemTypes = filter.IncludeItemTypes,
+                MediaTypes = filter.MediaTypes,
+                AncestorIds = filter.AncestorIds,
+                ExcludeItemIds = filter.ExcludeItemIds,
+                ItemIds = filter.ItemIds,
+                TopParentIds = filter.TopParentIds,
+                ParentId = filter.ParentId,
+                IsPlayed = filter.IsPlayed
+            };
+
+            var itemCountQuery = TranslateQuery(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId)), context, typeSubQuery)
+                .Where(e => e.ItemValues!.Any(f => itemValueTypes!.Contains(f.ItemValue.Type)));
+
+            var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];
+            var movieTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie];
+            var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];
+            var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum];
+            var musicArtistTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];
+            var audioTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Audio];
+            var trailerTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Trailer];
+
+            // Get the IDs from itemCountQuery to use in the join
+            var itemIds = itemCountQuery.Select(e => e.Id);
+
+            // Rewrite query to avoid SelectMany on navigation properties (which requires SQL APPLY, not supported on SQLite)
+            // Instead, start from ItemValueMaps and join with BaseItems
+            var countsByCleanName = context.ItemValuesMap
+                .Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))
+                .Where(ivm => itemIds.Contains(ivm.ItemId))
+                .Join(
+                    context.BaseItems,
+                    ivm => ivm.ItemId,
+                    e => e.Id,
+                    (ivm, e) => new { CleanName = ivm.ItemValue.CleanValue, e.Type })
+                .GroupBy(x => new { x.CleanName, x.Type })
+                .Select(g => new { g.Key.CleanName, g.Key.Type, Count = g.Count() })
+                .GroupBy(x => x.CleanName)
+                .ToDictionary(
+                    g => g.Key,
+                    g => new ItemCounts
+                    {
+                        SeriesCount = g.Where(x => x.Type == seriesTypeName).Sum(x => x.Count),
+                        EpisodeCount = g.Where(x => x.Type == episodeTypeName).Sum(x => x.Count),
+                        MovieCount = g.Where(x => x.Type == movieTypeName).Sum(x => x.Count),
+                        AlbumCount = g.Where(x => x.Type == musicAlbumTypeName).Sum(x => x.Count),
+                        ArtistCount = g.Where(x => x.Type == musicArtistTypeName).Sum(x => x.Count),
+                        SongCount = g.Where(x => x.Type == audioTypeName).Sum(x => x.Count),
+                        TrailerCount = g.Where(x => x.Type == trailerTypeName).Sum(x => x.Count),
+                    });
+
+            result.StartIndex = filter.StartIndex ?? 0;
+            result.Items =
+            [
+                .. query
+                    .AsEnumerable()
+                    .Where(e => e is not null)
+                    .Select(e =>
+                    {
+                        var item = DeserializeBaseItem(e, filter.SkipDeserialization);
+                        countsByCleanName.TryGetValue(e.CleanName ?? string.Empty, out var itemCount);
+                        return (item, itemCount);
+                    })
+                    .Where(x => x.item is not null)
+                    .Select(x => (x.item!, x.itemCount))
+            ];
+        }
+        else
+        {
+            result.StartIndex = filter.StartIndex ?? 0;
+            result.Items =
+            [
+                .. query
+                    .AsEnumerable()
+                    .Where(e => e != null)
+                    .Select(e => DeserializeBaseItem(e, filter.SkipDeserialization))
+                    .Where(item => item != null)
+                    .Select(item => (item!, (ItemCounts?)null))
+            ];
+        }
+
+        return result;
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs
new file mode 100644
index 0000000000..d4cdfdbc3e
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.QueryBuilding.cs
@@ -0,0 +1,541 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+#pragma warning disable CA1304 // Specify CultureInfo
+#pragma warning disable CA1311 // Specify a culture or use an invariant version
+#pragma warning disable CA1862 // Use the 'StringComparison' method overloads to perform case-insensitive string comparisons
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Enums;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Querying;
+using Microsoft.EntityFrameworkCore;
+using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+public sealed partial class BaseItemRepository
+{
+    /// <inheritdoc />
+    public IQueryable<BaseItemEntity> PrepareItemQuery(JellyfinDbContext context, InternalItemsQuery filter)
+    {
+        IQueryable<BaseItemEntity> dbQuery = context.BaseItems.AsNoTracking();
+        dbQuery = dbQuery.AsSingleQuery();
+
+        return dbQuery;
+    }
+
+    private IQueryable<BaseItemEntity> ApplyQueryFilter(IQueryable<BaseItemEntity> dbQuery, JellyfinDbContext context, InternalItemsQuery filter)
+    {
+        dbQuery = TranslateQuery(dbQuery, context, filter);
+        dbQuery = ApplyGroupingFilter(context, dbQuery, filter);
+        dbQuery = ApplyQueryPaging(dbQuery, filter);
+        dbQuery = ApplyNavigations(dbQuery, filter);
+        return dbQuery;
+    }
+
+    private IQueryable<BaseItemEntity> ApplyQueryPaging(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
+    {
+        if (filter.Limit.HasValue || filter.StartIndex.HasValue)
+        {
+            var offset = filter.StartIndex ?? 0;
+
+            if (offset > 0)
+            {
+                dbQuery = dbQuery.Skip(offset);
+            }
+
+            if (filter.Limit.HasValue)
+            {
+                dbQuery = dbQuery.Take(filter.Limit.Value);
+            }
+        }
+
+        return dbQuery;
+    }
+
+    private IQueryable<BaseItemEntity> ApplyGroupingFilter(JellyfinDbContext context, IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
+    {
+        // This whole block is needed to filter duplicate entries on request
+        // for the time being it cannot be used because it would destroy the ordering
+        // this results in "duplicate" responses for queries that try to lookup individual series or multiple versions but
+        // for that case the invoker has to run a DistinctBy(e => e.PresentationUniqueKey) on their own
+
+        var enableGroupByPresentationUniqueKey = EnableGroupByPresentationUniqueKey(filter);
+        if (enableGroupByPresentationUniqueKey && filter.GroupBySeriesPresentationUniqueKey)
+        {
+            var tempQuery = dbQuery.GroupBy(e => new { e.PresentationUniqueKey, e.SeriesPresentationUniqueKey }).Select(e => e.OrderBy(x => x.Id).FirstOrDefault()).Select(e => e!.Id);
+            dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));
+        }
+        else if (enableGroupByPresentationUniqueKey)
+        {
+            var tempQuery = dbQuery.GroupBy(e => e.PresentationUniqueKey).Select(e => e.OrderBy(x => x.Id).FirstOrDefault()).Select(e => e!.Id);
+            dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));
+        }
+        else if (filter.GroupBySeriesPresentationUniqueKey)
+        {
+            var tempQuery = dbQuery.GroupBy(e => e.SeriesPresentationUniqueKey).Select(e => e.OrderBy(x => x.Id).FirstOrDefault()).Select(e => e!.Id);
+            dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));
+        }
+        else
+        {
+            dbQuery = dbQuery.Distinct();
+        }
+
+        if (filter.CollapseBoxSetItems == true)
+        {
+            dbQuery = ApplyBoxSetCollapsing(context, dbQuery, filter.CollapseBoxSetItemTypes);
+
+            // Apply name-range filters after collapse so BoxSets are filtered by their own name,
+            // not by their children's names.
+            dbQuery = ApplyNameFilters(dbQuery, filter);
+        }
+
+        dbQuery = ApplyOrder(dbQuery, filter, context);
+
+        return dbQuery;
+    }
+
+    private IQueryable<BaseItemEntity> ApplyBoxSetCollapsing(
+        JellyfinDbContext context,
+        IQueryable<BaseItemEntity> dbQuery,
+        BaseItemKind[] collapsibleTypes)
+    {
+        var boxSetTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.BoxSet];
+
+        var currentIds = dbQuery.Select(e => e.Id);
+
+        if (collapsibleTypes.Length == 0)
+        {
+            // Collapse all item types into box sets
+            return ApplyBoxSetCollapsingAll(context, currentIds, boxSetTypeName);
+        }
+
+        // Only collapse specific item types, keep others untouched
+        var collapsibleTypeNames = collapsibleTypes.Select(t => _itemTypeLookup.BaseItemKindNames[t]).ToList();
+
+        // Items whose type is NOT collapsible (always kept in results)
+        var nonCollapsibleIds = currentIds
+            .Where(id => !context.BaseItems.Any(bi => bi.Id == id && collapsibleTypeNames.Contains(bi.Type)));
+
+        // Collapsible items that are NOT in any box set (kept in results)
+        var collapsibleNotInBoxSet = currentIds
+            .Where(id =>
+                context.BaseItems.Any(bi => bi.Id == id && collapsibleTypeNames.Contains(bi.Type))
+                && !context.BaseItems.Any(bs => bs.Id == id && bs.Type == boxSetTypeName)
+                && !context.LinkedChildren.Any(lc =>
+                    lc.ChildId == id
+                    && lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.Manual
+                    && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName)));
+
+        // Box set IDs containing at least one accessible collapsible child item
+        var boxSetIds = context.LinkedChildren
+            .Where(lc =>
+                lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.Manual
+                && currentIds.Contains(lc.ChildId)
+                && context.BaseItems.Any(bi => bi.Id == lc.ChildId && collapsibleTypeNames.Contains(bi.Type))
+                && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName))
+            .Select(lc => lc.ParentId)
+            .Distinct();
+
+        var collapsedIds = nonCollapsibleIds.Union(collapsibleNotInBoxSet).Union(boxSetIds);
+        return context.BaseItems.Where(e => collapsedIds.Contains(e.Id));
+    }
+
+    private static IQueryable<BaseItemEntity> ApplyBoxSetCollapsingAll(
+        JellyfinDbContext context,
+        IQueryable<Guid> currentIds,
+        string boxSetTypeName)
+    {
+        // Items that are NOT box sets and NOT in any box set
+        var notInBoxSet = currentIds
+            .Where(id =>
+                !context.BaseItems.Any(bs => bs.Id == id && bs.Type == boxSetTypeName)
+                && !context.LinkedChildren.Any(lc =>
+                    lc.ChildId == id
+                    && lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.Manual
+                    && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName)));
+
+        // Box set IDs containing at least one accessible child item
+        var boxSetIds = context.LinkedChildren
+            .Where(lc =>
+                lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.Manual
+                && currentIds.Contains(lc.ChildId)
+                && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName))
+            .Select(lc => lc.ParentId)
+            .Distinct();
+
+        var collapsedIds = notInBoxSet.Union(boxSetIds);
+        return context.BaseItems.Where(e => collapsedIds.Contains(e.Id));
+    }
+
+    private static IQueryable<BaseItemEntity> ApplyNameFilters(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
+    {
+        if (!string.IsNullOrWhiteSpace(filter.NameStartsWith))
+        {
+            var nameStartsWithLower = filter.NameStartsWith.ToLowerInvariant();
+            dbQuery = dbQuery.Where(e => e.SortName!.ToLower().StartsWith(nameStartsWithLower));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.NameStartsWithOrGreater))
+        {
+            var startsOrGreaterLower = filter.NameStartsWithOrGreater.ToLowerInvariant();
+            dbQuery = dbQuery.Where(e => e.SortName!.ToLower().CompareTo(startsOrGreaterLower) >= 0);
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.NameLessThan))
+        {
+            var lessThanLower = filter.NameLessThan.ToLowerInvariant();
+            dbQuery = dbQuery.Where(e => e.SortName!.ToLower().CompareTo(lessThanLower) < 0);
+        }
+
+        return dbQuery;
+    }
+
+    /// <inheritdoc />
+    public IQueryable<BaseItemEntity> ApplyNavigations(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
+    {
+        if (filter.TrailerTypes.Length > 0 || filter.IncludeItemTypes.Contains(BaseItemKind.Trailer))
+        {
+            dbQuery = dbQuery.Include(e => e.TrailerTypes);
+        }
+
+        if (filter.DtoOptions.ContainsField(ItemFields.ProviderIds))
+        {
+            dbQuery = dbQuery.Include(e => e.Provider);
+        }
+
+        if (filter.DtoOptions.ContainsField(ItemFields.Settings))
+        {
+            dbQuery = dbQuery.Include(e => e.LockedFields);
+        }
+
+        if (filter.DtoOptions.EnableUserData)
+        {
+            dbQuery = dbQuery.Include(e => e.UserData);
+        }
+
+        if (filter.DtoOptions.EnableImages)
+        {
+            dbQuery = dbQuery.Include(e => e.Images);
+        }
+
+        // Include LinkedChildEntities for container types and videos that use them
+        // (BoxSet, Playlist, CollectionFolder for manual linking; Video, Movie for alternate versions).
+        // When IncludeItemTypes is empty (any type may be returned), always include them to ensure
+        // LinkedChildren are loaded before items are saved back, preventing accidental deletion.
+        var linkedChildTypes = new[]
+        {
+            BaseItemKind.BoxSet,
+            BaseItemKind.Playlist,
+            BaseItemKind.CollectionFolder,
+            BaseItemKind.Video,
+            BaseItemKind.Movie
+        };
+        if (filter.IncludeItemTypes.Length == 0 || filter.IncludeItemTypes.Any(linkedChildTypes.Contains))
+        {
+            dbQuery = dbQuery.Include(e => e.LinkedChildEntities);
+        }
+
+        if (filter.IncludeExtras)
+        {
+            dbQuery = dbQuery.Include(e => e.Extras);
+        }
+
+        return dbQuery;
+    }
+
+    /// <inheritdoc />
+    public IQueryable<BaseItemEntity> ApplyOrder(IQueryable<BaseItemEntity> query, InternalItemsQuery filter, JellyfinDbContext context)
+    {
+        var orderBy = filter.OrderBy.Where(e => e.OrderBy != ItemSortBy.Default).ToArray();
+        var hasSearch = !string.IsNullOrEmpty(filter.SearchTerm);
+
+        // SeriesDatePlayed requires special handling to avoid correlated subqueries.
+        // Instead of running a MAX() subquery per-row in ORDER BY, we pre-aggregate
+        // max played dates per series in one query and left-join it.
+        if (!hasSearch && orderBy.Any(o => o.OrderBy == ItemSortBy.SeriesDatePlayed))
+        {
+            return ApplySeriesDatePlayedOrder(query, filter, context, orderBy);
+        }
+
+        IOrderedQueryable<BaseItemEntity>? orderedQuery = null;
+
+        if (hasSearch)
+        {
+            var relevanceExpression = OrderMapper.MapSearchRelevanceOrder(filter.SearchTerm!);
+            orderedQuery = query.OrderBy(relevanceExpression);
+        }
+
+        if (orderBy.Length > 0)
+        {
+            var firstOrdering = orderBy[0];
+            var expression = OrderMapper.MapOrderByField(firstOrdering.OrderBy, filter, context);
+
+            if (orderedQuery is null)
+            {
+                orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending
+                    ? query.OrderBy(expression)
+                    : query.OrderByDescending(expression);
+            }
+            else
+            {
+                orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending
+                    ? orderedQuery.ThenBy(expression)
+                    : orderedQuery.ThenByDescending(expression);
+            }
+
+            if (firstOrdering.OrderBy is ItemSortBy.Default or ItemSortBy.SortName)
+            {
+                orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending
+                    ? orderedQuery.ThenBy(e => e.Name)
+                    : orderedQuery.ThenByDescending(e => e.Name);
+            }
+
+            foreach (var item in orderBy.Skip(1))
+            {
+                expression = OrderMapper.MapOrderByField(item.OrderBy, filter, context);
+                orderedQuery = item.SortOrder == SortOrder.Ascending
+                    ? orderedQuery.ThenBy(expression)
+                    : orderedQuery.ThenByDescending(expression);
+            }
+        }
+
+        if (orderedQuery is null)
+        {
+            return query.OrderBy(e => e.SortName);
+        }
+
+        // Add SortName as final tiebreaker
+        if (!hasSearch && (orderBy.Length == 0 || orderBy.All(o => o.OrderBy is not ItemSortBy.SortName and not ItemSortBy.Name)))
+        {
+            orderedQuery = orderedQuery.ThenBy(e => e.SortName);
+        }
+
+        return orderedQuery;
+    }
+
+    private IQueryable<BaseItemEntity> ApplySeriesDatePlayedOrder(
+        IQueryable<BaseItemEntity> query,
+        InternalItemsQuery filter,
+        JellyfinDbContext context,
+        (ItemSortBy OrderBy, SortOrder SortOrder)[] orderBy)
+    {
+        // Pre-aggregate max played date per series key in ONE query.
+        // This generates a single: SELECT SeriesPresentationUniqueKey, MAX(LastPlayedDate) ... GROUP BY
+        // instead of a correlated subquery per outer row.
+        IQueryable<UserData> userDataQuery = filter.User is not null
+            ? context.UserData.Where(ud => ud.UserId == filter.User.Id && ud.Played)
+            : context.UserData.Where(ud => ud.Played);
+
+        var seriesMaxDates = userDataQuery
+            .Join(
+                context.BaseItems,
+                ud => ud.ItemId,
+                bi => bi.Id,
+                (ud, bi) => new { bi.SeriesPresentationUniqueKey, ud.LastPlayedDate })
+            .Where(x => x.SeriesPresentationUniqueKey != null)
+            .GroupBy(x => x.SeriesPresentationUniqueKey)
+            .Select(g => new { SeriesKey = g.Key!, MaxDate = g.Max(x => x.LastPlayedDate) });
+
+        var joined = query.LeftJoin(
+            seriesMaxDates,
+            e => e.PresentationUniqueKey,
+            s => s.SeriesKey,
+            (e, s) => new { Item = e, MaxDate = s != null ? s.MaxDate : (DateTime?)null });
+
+        var seriesSort = orderBy.First(o => o.OrderBy == ItemSortBy.SeriesDatePlayed);
+
+        return seriesSort.SortOrder == SortOrder.Ascending
+            ? joined.OrderBy(x => x.MaxDate).ThenBy(x => x.Item.SortName).Select(x => x.Item)
+            : joined.OrderByDescending(x => x.MaxDate).ThenBy(x => x.Item.SortName).Select(x => x.Item);
+    }
+
+    /// <summary>
+    /// Builds a query for descendants of an ancestor with user access filtering applied.
+    /// Uses recursive CTE to traverse both hierarchical (AncestorIds) and linked (LinkedChildren) relationships.
+    /// </summary>
+    /// <inheritdoc />
+    public IQueryable<BaseItemEntity> BuildAccessFilteredDescendantsQuery(
+        JellyfinDbContext context,
+        InternalItemsQuery filter,
+        Guid ancestorId)
+    {
+        // Use recursive CTE to get all descendants (hierarchical and linked)
+        var allDescendantIds = DescendantQueryHelper.GetAllDescendantIds(context, ancestorId);
+
+        var baseQuery = context.BaseItems
+            .Where(b => allDescendantIds.Contains(b.Id) && !b.IsFolder && !b.IsVirtualItem);
+
+        return ApplyAccessFiltering(context, baseQuery, filter);
+    }
+
+    /// <summary>
+    /// Applies user access filtering to a query.
+    /// Includes TopParentIds, parental rating, and tag filtering.
+    /// </summary>
+    /// <inheritdoc />
+    public IQueryable<BaseItemEntity> ApplyAccessFiltering(
+        JellyfinDbContext context,
+        IQueryable<BaseItemEntity> baseQuery,
+        InternalItemsQuery filter)
+    {
+        // Apply TopParentIds filtering (library folder access)
+        if (filter.TopParentIds.Length > 0)
+        {
+            var topParentIds = filter.TopParentIds;
+            baseQuery = baseQuery.Where(e => topParentIds.Contains(e.TopParentId!.Value));
+        }
+
+        // Apply parental rating filtering
+        if (filter.MaxParentalRating is not null)
+        {
+            baseQuery = baseQuery.Where(BuildMaxParentalRatingFilter(context, filter.MaxParentalRating));
+        }
+
+        // Apply block unrated items filtering
+        if (filter.BlockUnratedItems.Length > 0)
+        {
+            var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();
+            baseQuery = baseQuery.Where(e =>
+                e.InheritedParentalRatingValue != null || !unratedItemTypes.Contains(e.UnratedType));
+        }
+
+        // Apply excluded tags filtering (blocked tags)
+        if (filter.ExcludeInheritedTags.Length > 0)
+        {
+            var excludedTags = filter.ExcludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();
+            baseQuery = baseQuery.Where(e =>
+                !context.ItemValuesMap.Any(f =>
+                    f.ItemValue.Type == ItemValueType.Tags
+                    && excludedTags.Contains(f.ItemValue.CleanValue)
+                    && (f.ItemId == e.Id
+                        || (e.SeriesId.HasValue && f.ItemId == e.SeriesId.Value)
+                        || e.Parents!.Any(p => f.ItemId == p.ParentItemId)
+                        || (e.TopParentId.HasValue && f.ItemId == e.TopParentId.Value))));
+        }
+
+        // Apply included tags filtering (allowed tags - item must have at least one)
+        if (filter.IncludeInheritedTags.Length > 0)
+        {
+            var includeTags = filter.IncludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();
+            baseQuery = baseQuery.Where(e =>
+                context.ItemValuesMap.Any(f =>
+                    f.ItemValue.Type == ItemValueType.Tags
+                    && includeTags.Contains(f.ItemValue.CleanValue)
+                    && (f.ItemId == e.Id
+                        || (e.SeriesId.HasValue && f.ItemId == e.SeriesId.Value)
+                        || e.Parents!.Any(p => f.ItemId == p.ParentItemId)
+                        || (e.TopParentId.HasValue && f.ItemId == e.TopParentId.Value))));
+        }
+
+        return baseQuery;
+    }
+
+    /// <summary>
+    /// Builds a filter expression for max parental rating that handles both rated items
+    /// and unrated BoxSets/Playlists (which check linked children's ratings).
+    /// </summary>
+    private static Expression<Func<BaseItemEntity, bool>> BuildMaxParentalRatingFilter(
+        JellyfinDbContext context,
+        ParentalRatingScore maxRating)
+    {
+        var maxScore = maxRating.Score;
+        var maxSubScore = maxRating.SubScore ?? 0;
+        var linkedChildren = context.LinkedChildren;
+
+        return e =>
+            // Item has a rating: check against limit
+            (e.InheritedParentalRatingValue != null
+                && (e.InheritedParentalRatingValue < maxScore
+                    || (e.InheritedParentalRatingValue == maxScore && (e.InheritedParentalRatingSubValue ?? 0) <= maxSubScore)))
+            // Item has no rating
+            || (e.InheritedParentalRatingValue == null
+                && (
+                    // No linked children (not a BoxSet/Playlist): pass as unrated
+                    !linkedChildren.Any(lc => lc.ParentId == e.Id)
+                    // Has linked children: at least one child must be within limits
+                    || linkedChildren.Any(lc => lc.ParentId == e.Id
+                        && (lc.Child!.InheritedParentalRatingValue == null
+                            || lc.Child.InheritedParentalRatingValue < maxScore
+                            || (lc.Child.InheritedParentalRatingValue == maxScore
+                                && (lc.Child.InheritedParentalRatingSubValue ?? 0) <= maxSubScore)))));
+    }
+
+    private Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user)
+    {
+        ArgumentNullException.ThrowIfNull(folderIds);
+        ArgumentNullException.ThrowIfNull(user);
+
+        if (folderIds.Count == 0)
+        {
+            return new Dictionary<Guid, (int Played, int Total)>();
+        }
+
+        using var dbContext = _dbProvider.CreateDbContext();
+        var folderIdsArray = folderIds.ToArray();
+        var filter = new InternalItemsQuery(user);
+        var userId = user.Id;
+
+        var leafItems = dbContext.BaseItems
+            .Where(b => !b.IsFolder && !b.IsVirtualItem);
+        leafItems = ApplyAccessFiltering(dbContext, leafItems, filter);
+
+        var playedLeafItems = leafItems
+            .Select(b => new { b.Id, Played = b.UserData!.Any(ud => ud.UserId == userId && ud.Played) });
+
+        var ancestorLeaves = dbContext.AncestorIds
+            .WhereOneOrMany(folderIdsArray, a => a.ParentItemId)
+            .Join(
+                playedLeafItems,
+                a => a.ItemId,
+                b => b.Id,
+                (a, b) => new { FolderId = a.ParentItemId, b.Id, b.Played });
+
+        var linkedLeaves = dbContext.LinkedChildren
+            .WhereOneOrMany(folderIdsArray, lc => lc.ParentId)
+            .Join(
+                playedLeafItems,
+                lc => lc.ChildId,
+                b => b.Id,
+                (lc, b) => new { FolderId = lc.ParentId, b.Id, b.Played });
+
+        var linkedFolderLeaves = dbContext.LinkedChildren
+            .WhereOneOrMany(folderIdsArray, lc => lc.ParentId)
+            .Join(
+                dbContext.BaseItems.Where(b => b.IsFolder),
+                lc => lc.ChildId,
+                b => b.Id,
+                (lc, b) => new { lc.ParentId, FolderChildId = b.Id })
+            .Join(
+                dbContext.AncestorIds,
+                x => x.FolderChildId,
+                a => a.ParentItemId,
+                (x, a) => new { x.ParentId, DescendantId = a.ItemId })
+            .Join(
+                playedLeafItems,
+                x => x.DescendantId,
+                b => b.Id,
+                (x, b) => new { FolderId = x.ParentId, b.Id, b.Played });
+
+        var results = ancestorLeaves
+            .Union(linkedLeaves)
+            .Union(linkedFolderLeaves)
+            .GroupBy(x => x.FolderId)
+            .Select(g => new
+            {
+                FolderId = g.Key,
+                Total = g.Select(x => x.Id).Distinct().Count(),
+                Played = g.Where(x => x.Played).Select(x => x.Id).Distinct().Count()
+            })
+            .ToDictionary(x => x.FolderId, x => (x.Played, x.Total));
+
+        return results;
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs
new file mode 100644
index 0000000000..3487fa09d7
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs
@@ -0,0 +1,553 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Querying;
+using Microsoft.EntityFrameworkCore;
+using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+public sealed partial class BaseItemRepository
+{
+    /// <inheritdoc />
+    public IReadOnlyList<Guid> GetItemIdsList(InternalItemsQuery filter)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        PrepareFilterQuery(filter);
+
+        using var context = _dbProvider.CreateDbContext();
+        return ApplyQueryFilter(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId)), context, filter).Select(e => e.Id).ToArray();
+    }
+
+    /// <inheritdoc />
+    public QueryResult<BaseItemDto> GetItems(InternalItemsQuery filter)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        if (!filter.EnableTotalRecordCount || (!filter.Limit.HasValue && (filter.StartIndex ?? 0) == 0))
+        {
+            var returnList = GetItemList(filter);
+            return new QueryResult<BaseItemDto>(
+                filter.StartIndex,
+                returnList.Count,
+                returnList);
+        }
+
+        PrepareFilterQuery(filter);
+        var result = new QueryResult<BaseItemDto>();
+
+        using var context = _dbProvider.CreateDbContext();
+
+        IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);
+
+        dbQuery = TranslateQuery(dbQuery, context, filter);
+        dbQuery = ApplyGroupingFilter(context, dbQuery, filter);
+
+        if (filter.EnableTotalRecordCount)
+        {
+            result.TotalRecordCount = dbQuery.Count();
+        }
+
+        dbQuery = ApplyQueryPaging(dbQuery, filter);
+        dbQuery = ApplyNavigations(dbQuery, filter);
+
+        result.Items = dbQuery.AsEnumerable().Where(e => e != null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).Where(dto => dto != null).ToArray()!;
+        result.StartIndex = filter.StartIndex ?? 0;
+        return result;
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<BaseItemDto> GetItemList(InternalItemsQuery filter)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        PrepareFilterQuery(filter);
+
+        using var context = _dbProvider.CreateDbContext();
+        IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);
+
+        dbQuery = TranslateQuery(dbQuery, context, filter);
+
+        dbQuery = ApplyGroupingFilter(context, dbQuery, filter);
+        dbQuery = ApplyQueryPaging(dbQuery, filter);
+
+        var hasRandomSort = filter.OrderBy.Any(e => e.OrderBy == ItemSortBy.Random);
+        if (hasRandomSort)
+        {
+            var orderedIds = dbQuery.Select(e => e.Id).ToList();
+            if (orderedIds.Count == 0)
+            {
+                return Array.Empty<BaseItemDto>();
+            }
+
+            var itemsById = ApplyNavigations(context.BaseItems.Where(e => orderedIds.Contains(e.Id)), filter)
+                .AsEnumerable()
+                .Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))
+                .Where(dto => dto != null)
+                .ToDictionary(i => i!.Id);
+
+            return orderedIds.Where(itemsById.ContainsKey).Select(id => itemsById[id]).ToArray()!;
+        }
+
+        dbQuery = ApplyNavigations(dbQuery, filter);
+
+        return dbQuery.AsEnumerable().Where(e => e != null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).Where(dto => dto != null).ToArray()!;
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<BaseItemDto> GetLatestItemList(InternalItemsQuery filter, CollectionType collectionType)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        PrepareFilterQuery(filter);
+
+        // Early exit if collection type is not supported
+        if (collectionType is not CollectionType.movies and not CollectionType.tvshows and not CollectionType.music)
+        {
+            return [];
+        }
+
+        var limit = filter.Limit;
+        using var context = _dbProvider.CreateDbContext();
+
+        var baseQuery = PrepareItemQuery(context, filter);
+        baseQuery = TranslateQuery(baseQuery, context, filter);
+
+        if (collectionType == CollectionType.tvshows)
+        {
+            return GetLatestTvShowItems(context, baseQuery, filter, limit);
+        }
+
+        // Find the top N group keys ordered by most recent DateCreated.
+        // Movies group by PresentationUniqueKey (alternate versions like 4K/1080p share a key).
+        // Music groups by Album.
+        Expression<Func<BaseItemEntity, bool>> groupKeyFilter;
+        Expression<Func<BaseItemEntity, string?>> groupKeySelector;
+
+        if (collectionType is CollectionType.movies)
+        {
+            groupKeyFilter = e => e.PresentationUniqueKey != null;
+            groupKeySelector = e => e.PresentationUniqueKey;
+        }
+        else
+        {
+            groupKeyFilter = e => e.Album != null;
+            groupKeySelector = e => e.Album;
+        }
+
+        var topGroupKeys = baseQuery
+            .Where(groupKeyFilter)
+            .GroupBy(groupKeySelector)
+            .Select(g => new { GroupKey = g.Key!, MaxDate = g.Max(e => e.DateCreated) })
+            .OrderByDescending(g => g.MaxDate);
+
+        if (filter.Limit.HasValue)
+        {
+            topGroupKeys = topGroupKeys.Take(filter.Limit.Value).OrderByDescending(g => g.MaxDate);
+        }
+
+        // Get only the first (most recent) item ID per group using a lightweight projection,
+        // then fetch full entities only for those items. This avoids loading all versions/tracks
+        // with expensive navigation properties just to discard duplicates.
+        var topGroupKeyList = topGroupKeys.Select(g => g.GroupKey).ToList();
+        // ThenByDescending(Id) is a tiebreaker for deterministic ordering when multiple items
+        // share the same DateCreated timestamp — without it, SQL returns arbitrary order across queries.
+        var allItemsLite = collectionType switch
+        {
+            CollectionType.movies => baseQuery
+                .Where(e => e.PresentationUniqueKey != null && topGroupKeyList.Contains(e.PresentationUniqueKey))
+                .OrderByDescending(e => e.DateCreated)
+                .ThenByDescending(e => e.Id)
+                .Select(e => new { e.Id, GroupKey = e.PresentationUniqueKey })
+                .AsEnumerable(),
+            _ => baseQuery
+                .Where(e => e.Album != null && topGroupKeyList.Contains(e.Album))
+                .OrderByDescending(e => e.DateCreated)
+                .ThenByDescending(e => e.Id)
+                .Select(e => new { e.Id, GroupKey = e.Album })
+                .AsEnumerable()
+        };
+
+        // Client-side DistinctBy: EF Core/SQLite cannot reliably translate
+        // GroupBy(...).Select(g => g.First()) to SQL. The projection is lightweight
+        // (only Id + GroupKey for ~50 items), so client-side dedup is negligible.
+        var firstIds = allItemsLite
+            .DistinctBy(e => e.GroupKey)
+            .Select(e => e.Id)
+            .AsEnumerable();
+
+        var itemsQuery = context.BaseItems.AsNoTracking().Where(e => firstIds.Contains(e.Id));
+        itemsQuery = ApplyNavigations(itemsQuery, filter);
+
+        return itemsQuery
+            .OrderByDescending(e => e.DateCreated)
+            .ThenByDescending(e => e.Id)
+            .AsEnumerable()
+            .Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))
+            .Where(dto => dto != null)
+            .ToArray()!;
+    }
+
+    /// <summary>
+    /// Gets the latest TV show items with smart Season/Series container selection.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This method implements intelligent container selection for TV shows in the "Latest" section.
+    /// Instead of always showing individual episodes, it analyzes recent additions and may return
+    /// a Season or Series container when multiple related episodes were recently added.
+    /// </para>
+    /// <para>
+    /// The selection logic is:
+    /// <list type="bullet">
+    ///     <item>If recent episodes span multiple seasons → return the Series</item>
+    ///     <item>If multiple recent episodes are from one season AND the series has multiple seasons → return the Season</item>
+    ///     <item>If multiple recent episodes are from one season AND the series has only one season → return the Series</item>
+    ///     <item>Otherwise → return the most recent Episode</item>
+    /// </list>
+    /// </para>
+    /// </remarks>
+    /// <param name="context">The database context.</param>
+    /// <param name="baseQuery">The base query with filters already applied.</param>
+    /// <param name="filter">The query filter options.</param>
+    /// <param name="limit">Maximum number of items to return.</param>
+    /// <returns>A list of BaseItemDto representing the latest TV content.</returns>
+    private IReadOnlyList<BaseItemDto> GetLatestTvShowItems(JellyfinDbContext context, IQueryable<BaseItemEntity> baseQuery, InternalItemsQuery filter, int? limit)
+    {
+        // Episodes added within this window are considered "recently added together"
+        const double RecentAdditionWindowHours = 24.0;
+
+        // Step 1: Find the top N series with recently added content, ordered by most recent addition
+        var topSeriesWithDates = baseQuery
+            .Where(e => e.SeriesName != null)
+            .GroupBy(e => e.SeriesName)
+            .Select(g => new { SeriesName = g.Key!, MaxDate = g.Max(e => e.DateCreated) })
+            .OrderByDescending(g => g.MaxDate);
+
+        if (limit.HasValue)
+        {
+            topSeriesWithDates = topSeriesWithDates.Take(limit.Value).OrderByDescending(g => g.MaxDate);
+        }
+
+        var topSeriesNames = topSeriesWithDates.Select(g => g.SeriesName).AsEnumerable();
+
+        // Compute a global date cutoff: the oldest series' max date minus the window.
+        // Episodes before this cutoff cannot be in any series' "recent additions" window,
+        // so we can safely exclude them to avoid loading ancient episodes.
+        var globalCutoff = topSeriesWithDates.Any()
+            ? topSeriesWithDates.Min(g => g.MaxDate)?.AddHours(-RecentAdditionWindowHours)
+            : null;
+
+        // Fetch only the columns needed for analysis (lightweight projection).
+        var episodeQuery = baseQuery.Where(e => e.SeriesName != null && topSeriesNames.Contains(e.SeriesName));
+        if (globalCutoff is not null)
+        {
+            episodeQuery = episodeQuery.Where(e => e.DateCreated >= globalCutoff);
+        }
+
+        var allEpisodes = episodeQuery
+            .OrderByDescending(e => e.DateCreated)
+            .ThenByDescending(e => e.Id)
+            .Select(e => new { e.Id, e.SeriesName, e.DateCreated, e.SeasonId, e.SeriesId })
+            .AsEnumerable();
+
+        // Collect all season/series IDs we'll need to look up for count information
+        var allSeasonIds = new HashSet<Guid>();
+        var allSeriesIds = new HashSet<Guid>();
+
+        // Analysis data for each series: recent episode count, season IDs, and the most recent episode ID
+        var analysisData = new List<(
+            int RecentEpisodeCount,
+            List<Guid> SeasonIds,
+            Guid? FirstRecentSeriesId,
+            DateTime MaxDate,
+            Guid MostRecentEpisodeId)>();
+
+        // Step 3: Analyze each series to identify recent additions within the time window
+        foreach (var group in allEpisodes.GroupBy(e => e.SeriesName))
+        {
+            var episodes = group.ToList();
+            var mostRecentDate = episodes[0].DateCreated ?? DateTime.MinValue;
+            var recentCutoff = mostRecentDate.AddHours(-RecentAdditionWindowHours);
+
+            // Find episodes added within the recent window
+            var recentEpisodeCount = 0;
+            var seasonIdSet = new HashSet<Guid>();
+            Guid? firstRecentSeriesId = null;
+
+            foreach (var ep in episodes)
+            {
+                if (ep.DateCreated >= recentCutoff)
+                {
+                    recentEpisodeCount++;
+                    if (ep.SeasonId.HasValue)
+                    {
+                        seasonIdSet.Add(ep.SeasonId.Value);
+                    }
+
+                    firstRecentSeriesId ??= ep.SeriesId;
+                }
+            }
+
+            var seasonIds = seasonIdSet.ToList();
+            analysisData.Add((recentEpisodeCount, seasonIds, firstRecentSeriesId, mostRecentDate, episodes[0].Id));
+
+            // Track all unique season/series IDs for batch lookups
+            foreach (var sid in seasonIds)
+            {
+                allSeasonIds.Add(sid);
+            }
+
+            if (firstRecentSeriesId.HasValue)
+            {
+                allSeriesIds.Add(firstRecentSeriesId.Value);
+            }
+        }
+
+        // Step 4: Batch fetch counts - episodes per season and seasons per series
+        // These counts help determine whether to show Season or Series as the container
+        var episodeType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];
+        var seasonType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Season];
+        var seasonEpisodeCounts = allSeasonIds.Count > 0
+            ? context.BaseItems
+                .AsNoTracking()
+                .Where(e => e.SeasonId.HasValue && allSeasonIds.Contains(e.SeasonId.Value) && e.Type == episodeType)
+                .GroupBy(e => e.SeasonId!.Value)
+                .Select(g => new { SeasonId = g.Key, Count = g.Count() })
+                .ToDictionary(x => x.SeasonId, x => x.Count)
+            : [];
+
+        var seriesSeasonCounts = allSeriesIds.Count > 0
+            ? context.BaseItems
+                .AsNoTracking()
+                .Where(e => e.SeriesId.HasValue && allSeriesIds.Contains(e.SeriesId.Value) && e.Type == seasonType)
+                .GroupBy(e => e.SeriesId!.Value)
+                .Select(g => new { SeriesId = g.Key, Count = g.Count() })
+                .ToDictionary(x => x.SeriesId, x => x.Count)
+            : [];
+
+        // Step 5: Apply the container selection logic for each series.
+        // For each series, decide which entity best represents the recent additions:
+        //   - 1 episode added → show the Episode itself
+        //   - Multiple episodes in 1 season (multi-season series) → show the Season
+        //   - Multiple episodes in 1 season (single-season series) → show the Series
+        //   - Episodes across multiple seasons → show the Series
+        var entitiesToFetch = new HashSet<Guid>();
+        var seriesResults = new List<(Guid? SeasonId, Guid? SeriesId, DateTime MaxDate, Guid MostRecentEpisodeId)>(analysisData.Count);
+
+        foreach (var (recentEpisodeCount, seasonIds, firstRecentSeriesId, maxDate, mostRecentEpisodeId) in analysisData)
+        {
+            Guid? seasonId = null;
+            Guid? seriesId = null;
+
+            if (seasonIds.Count == 1)
+            {
+                // All recent episodes are from a single season
+                var sid = seasonIds[0];
+                var totalEpisodes = seasonEpisodeCounts.GetValueOrDefault(sid, 0);
+                var totalSeasonsInSeries = firstRecentSeriesId.HasValue
+                    ? seriesSeasonCounts.GetValueOrDefault(firstRecentSeriesId.Value, 1)
+                    : 1;
+
+                // Check if multiple episodes were added, or if all episodes in the season were added
+                var hasMultipleOrAllEpisodes = recentEpisodeCount > 1 || recentEpisodeCount == totalEpisodes;
+
+                if (totalSeasonsInSeries > 1 && hasMultipleOrAllEpisodes)
+                {
+                    // Multi-season series with bulk additions: show the Season
+                    seasonId = sid;
+                    entitiesToFetch.Add(sid);
+                }
+                else if (hasMultipleOrAllEpisodes && firstRecentSeriesId.HasValue)
+                {
+                    // Single-season series with bulk additions: show the Series
+                    seriesId = firstRecentSeriesId;
+                    entitiesToFetch.Add(firstRecentSeriesId.Value);
+                }
+
+                // Otherwise: single episode, will fall through to show the Episode
+            }
+            else if (seasonIds.Count > 1 && firstRecentSeriesId.HasValue)
+            {
+                // Recent episodes span multiple seasons: show the Series
+                seriesId = firstRecentSeriesId;
+                entitiesToFetch.Add(seriesId!.Value);
+            }
+
+            if (seasonId is null && seriesId is null)
+            {
+                entitiesToFetch.Add(mostRecentEpisodeId);
+            }
+
+            seriesResults.Add((seasonId, seriesId, maxDate, mostRecentEpisodeId));
+        }
+
+        // Step 6: Fetch the Season/Series entities we decided to return
+        var entities = entitiesToFetch.Count > 0
+            ? ApplyNavigations(
+                    context.BaseItems.AsNoTracking().Where(e => entitiesToFetch.Contains(e.Id)),
+                    filter)
+                .AsSingleQuery()
+                .ToDictionary(e => e.Id)
+            : [];
+
+        // Step 7: Build final results, preferring Season > Series > Episode.
+        // All needed entities are already fetched in step 6 with navigation properties.
+        var results = new List<(BaseItemEntity Entity, DateTime MaxDate)>(seriesResults.Count);
+        foreach (var (seasonId, seriesId, maxDate, mostRecentEpisodeId) in seriesResults)
+        {
+            if (seasonId.HasValue && entities.TryGetValue(seasonId.Value, out var seasonEntity))
+            {
+                results.Add((seasonEntity, maxDate));
+                continue;
+            }
+
+            if (seriesId.HasValue && entities.TryGetValue(seriesId.Value, out var seriesEntity))
+            {
+                results.Add((seriesEntity, maxDate));
+                continue;
+            }
+
+            if (entities.TryGetValue(mostRecentEpisodeId, out var episodeEntity))
+            {
+                results.Add((episodeEntity, maxDate));
+            }
+        }
+
+        var finalResults = results
+            .OrderByDescending(r => r.MaxDate)
+            .ThenByDescending(r => r.Entity.Id);
+
+        if (limit.HasValue)
+        {
+            finalResults = finalResults
+            .Take(limit.Value)
+            .OrderByDescending(r => r.MaxDate)
+            .ThenByDescending(r => r.Entity.Id);
+        }
+
+        return finalResults
+            .Select(r => DeserializeBaseItem(r.Entity, filter.SkipDeserialization))
+            .Where(dto => dto is not null)
+            .ToArray()!;
+    }
+
+    /// <inheritdoc/>
+    public async Task<bool> ItemExistsAsync(Guid id)
+    {
+        var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
+        await using (dbContext.ConfigureAwait(false))
+        {
+            return await dbContext.BaseItems.AnyAsync(f => f.Id == id).ConfigureAwait(false);
+        }
+    }
+
+    /// <inheritdoc  />
+    public BaseItemDto? RetrieveItem(Guid id)
+    {
+        if (id.IsEmpty())
+        {
+            throw new ArgumentException("Guid can't be empty", nameof(id));
+        }
+
+        using var context = _dbProvider.CreateDbContext();
+        var dbQuery = PrepareItemQuery(context, new()
+        {
+            DtoOptions = new()
+            {
+                EnableImages = true
+            }
+        });
+        dbQuery = dbQuery.Include(e => e.TrailerTypes)
+            .Include(e => e.Provider)
+            .Include(e => e.LockedFields)
+            .Include(e => e.UserData)
+            .Include(e => e.Images)
+            .Include(e => e.LinkedChildEntities)
+            .AsSingleQuery();
+
+        var item = dbQuery.FirstOrDefault(e => e.Id == id);
+        if (item is null)
+        {
+            return null;
+        }
+
+        return DeserializeBaseItem(item);
+    }
+
+    /// <inheritdoc />
+    public bool GetIsPlayed(User user, Guid id, bool recursive)
+    {
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        if (recursive)
+        {
+            var descendantIds = DescendantQueryHelper.GetAllDescendantIds(dbContext, id);
+
+            return dbContext.BaseItems
+                    .Where(e => descendantIds.Contains(e.Id) && !e.IsFolder && !e.IsVirtualItem)
+                    .All(f => f.UserData!.Any(e => e.UserId == user.Id && e.Played));
+        }
+
+        return dbContext.BaseItems.Where(e => e.ParentId == id).All(f => f.UserData!.Any(e => e.UserId == user.Id && e.Played));
+    }
+
+    /// <inheritdoc />
+    public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        PrepareFilterQuery(filter);
+
+        using var context = _dbProvider.CreateDbContext();
+        var baseQuery = PrepareItemQuery(context, filter);
+        baseQuery = TranslateQuery(baseQuery, context, filter);
+
+        var matchingItemIds = baseQuery.Select(e => e.Id);
+
+        var years = baseQuery
+            .Where(e => e.ProductionYear != null && e.ProductionYear > 0)
+            .Select(e => e.ProductionYear!.Value)
+            .Distinct()
+            .OrderBy(y => y)
+            .ToArray();
+
+        var officialRatings = baseQuery
+            .Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)
+            .Select(e => e.OfficialRating!)
+            .Distinct()
+            .OrderBy(r => r)
+            .ToArray();
+
+        var tags = context.ItemValuesMap
+            .Where(ivm => ivm.ItemValue.Type == ItemValueType.Tags)
+            .Where(ivm => matchingItemIds.Contains(ivm.ItemId))
+            .Select(ivm => ivm.ItemValue)
+            .GroupBy(iv => iv.CleanValue)
+            .Select(g => g.OrderBy(iv => iv.Value).First().Value)
+            .OrderBy(t => t)
+            .ToArray();
+
+        var genres = context.ItemValuesMap
+            .Where(ivm => ivm.ItemValue.Type == ItemValueType.Genre)
+            .Where(ivm => matchingItemIds.Contains(ivm.ItemId))
+            .Select(ivm => ivm.ItemValue)
+            .GroupBy(iv => iv.CleanValue)
+            .Select(g => g.OrderBy(iv => iv.Value).First().Value)
+            .OrderBy(g => g)
+            .ToArray();
+
+        return new QueryFiltersLegacy
+        {
+            Years = years,
+            OfficialRatings = officialRatings,
+            Tags = tags,
+            Genres = genres
+        };
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
new file mode 100644
index 0000000000..f3c9f2adbd
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
@@ -0,0 +1,1118 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+#pragma warning disable CA1304 // Specify CultureInfo
+#pragma warning disable CA1309 // Use ordinal string comparison
+#pragma warning disable CA1311 // Specify a culture or use an invariant version
+#pragma warning disable CA1307 // Specify StringComparison for clarity
+#pragma warning disable CA1862 // Use the 'StringComparison' method overloads to perform case-insensitive string comparisons
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Linq.Expressions;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.MatchCriteria;
+using Jellyfin.Extensions;
+using Jellyfin.Server.Implementations.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Entities;
+using Microsoft.EntityFrameworkCore;
+using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+public sealed partial class BaseItemRepository
+{
+    private static readonly IReadOnlyList<char> SearchWildcardTerms = ['%', '_', '[', ']', '^'];
+
+    private static readonly string ImdbProviderName = MetadataProvider.Imdb.ToString().ToLowerInvariant();
+    private static readonly string TmdbProviderName = MetadataProvider.Tmdb.ToString().ToLowerInvariant();
+    private static readonly string TvdbProviderName = MetadataProvider.Tvdb.ToString().ToLowerInvariant();
+
+    /// <inheritdoc />
+    public IQueryable<BaseItemEntity> TranslateQuery(
+        IQueryable<BaseItemEntity> baseQuery,
+        JellyfinDbContext context,
+        InternalItemsQuery filter)
+    {
+        const int HDWidth = 1200;
+        const int UHDWidth = 3800;
+        const int UHDHeight = 2100;
+
+        var minWidth = filter.MinWidth;
+        var maxWidth = filter.MaxWidth;
+        var now = DateTime.UtcNow;
+
+        if (filter.IsHD.HasValue || filter.Is4K.HasValue)
+        {
+            bool includeSD = false;
+            bool includeHD = false;
+            bool include4K = false;
+
+            if (filter.IsHD.HasValue && !filter.IsHD.Value)
+            {
+                includeSD = true;
+            }
+
+            if (filter.IsHD.HasValue && filter.IsHD.Value)
+            {
+                includeHD = true;
+            }
+
+            if (filter.Is4K.HasValue && filter.Is4K.Value)
+            {
+                include4K = true;
+            }
+
+            baseQuery = baseQuery.Where(e =>
+                (includeSD && e.Width < HDWidth) ||
+                (includeHD && e.Width >= HDWidth && !(e.Width >= UHDWidth || e.Height >= UHDHeight)) ||
+                (include4K && (e.Width >= UHDWidth || e.Height >= UHDHeight)));
+        }
+
+        if (minWidth.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.Width >= minWidth);
+        }
+
+        if (filter.MinHeight.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.Height >= filter.MinHeight);
+        }
+
+        if (maxWidth.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.Width <= maxWidth);
+        }
+
+        if (filter.MaxHeight.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.Height <= filter.MaxHeight);
+        }
+
+        if (filter.IsLocked.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.IsLocked == filter.IsLocked);
+        }
+
+        var tags = filter.Tags.ToList();
+        var excludeTags = filter.ExcludeTags.ToList();
+
+        if (filter.IsMovie.HasValue)
+        {
+            var shouldIncludeAllMovieTypes = filter.IsMovie.Value
+                && (filter.IncludeItemTypes.Length == 0
+                    || filter.IncludeItemTypes.Contains(BaseItemKind.Movie)
+                    || filter.IncludeItemTypes.Contains(BaseItemKind.Trailer));
+
+            if (!shouldIncludeAllMovieTypes)
+            {
+                baseQuery = baseQuery.Where(e => e.IsMovie == filter.IsMovie.Value);
+            }
+        }
+
+        if (filter.IsSeries.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.IsSeries == filter.IsSeries);
+        }
+
+        if (filter.IsSports.HasValue)
+        {
+            if (filter.IsSports.Value)
+            {
+                tags.Add("Sports");
+            }
+            else
+            {
+                excludeTags.Add("Sports");
+            }
+        }
+
+        if (filter.IsNews.HasValue)
+        {
+            if (filter.IsNews.Value)
+            {
+                tags.Add("News");
+            }
+            else
+            {
+                excludeTags.Add("News");
+            }
+        }
+
+        if (filter.IsKids.HasValue)
+        {
+            if (filter.IsKids.Value)
+            {
+                tags.Add("Kids");
+            }
+            else
+            {
+                excludeTags.Add("Kids");
+            }
+        }
+
+        if (!string.IsNullOrEmpty(filter.SearchTerm))
+        {
+            var cleanedSearchTerm = filter.SearchTerm.GetCleanValue();
+            var originalSearchTerm = filter.SearchTerm;
+            if (SearchWildcardTerms.Any(f => cleanedSearchTerm.Contains(f)))
+            {
+                cleanedSearchTerm = $"%{cleanedSearchTerm.Trim('%')}%";
+                var likeSearchTerm = $"%{originalSearchTerm.Trim('%')}%";
+                baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName!, cleanedSearchTerm) || (e.OriginalTitle != null && EF.Functions.Like(e.OriginalTitle, likeSearchTerm)));
+            }
+            else
+            {
+                var likeSearchTerm = $"%{originalSearchTerm}%";
+                baseQuery = baseQuery.Where(e => e.CleanName!.Contains(cleanedSearchTerm) || (e.OriginalTitle != null && EF.Functions.Like(e.OriginalTitle, likeSearchTerm)));
+            }
+        }
+
+        if (filter.IsFolder.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.IsFolder == filter.IsFolder);
+        }
+
+        var includeTypes = filter.IncludeItemTypes;
+
+        // Only specify excluded types if no included types are specified
+        if (filter.IncludeItemTypes.Length == 0)
+        {
+            var excludeTypes = filter.ExcludeItemTypes;
+            if (excludeTypes.Length == 1)
+            {
+                if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeTypes[0], out var excludeTypeName))
+                {
+                    baseQuery = baseQuery.Where(e => e.Type != excludeTypeName);
+                }
+            }
+            else if (excludeTypes.Length > 1)
+            {
+                var excludeTypeName = new List<string>();
+                foreach (var excludeType in excludeTypes)
+                {
+                    if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeType, out var baseItemKindName))
+                    {
+                        excludeTypeName.Add(baseItemKindName!);
+                    }
+                }
+
+                baseQuery = baseQuery.Where(e => !excludeTypeName.Contains(e.Type));
+            }
+        }
+        else
+        {
+            string[] types = includeTypes.Select(f => _itemTypeLookup.BaseItemKindNames.GetValueOrDefault(f)).Where(e => e != null).ToArray()!;
+            baseQuery = baseQuery.WhereOneOrMany(types, f => f.Type);
+        }
+
+        if (filter.ChannelIds.Count > 0)
+        {
+            baseQuery = baseQuery.Where(e => e.ChannelId != null && filter.ChannelIds.Contains(e.ChannelId.Value));
+        }
+
+        if (!filter.ParentId.IsEmpty())
+        {
+            baseQuery = baseQuery.Where(e => e.ParentId!.Value == filter.ParentId);
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.Path))
+        {
+            var pathToQuery = GetPathToSave(filter.Path);
+            baseQuery = baseQuery.Where(e => e.Path == pathToQuery);
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.PresentationUniqueKey))
+        {
+            baseQuery = baseQuery.Where(e => e.PresentationUniqueKey == filter.PresentationUniqueKey);
+        }
+
+        if (filter.MinCommunityRating.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.CommunityRating >= filter.MinCommunityRating);
+        }
+
+        if (filter.MinIndexNumber.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.IndexNumber >= filter.MinIndexNumber);
+        }
+
+        if (filter.MinParentAndIndexNumber.HasValue)
+        {
+            baseQuery = baseQuery
+                .Where(e => (e.ParentIndexNumber == filter.MinParentAndIndexNumber.Value.ParentIndexNumber && e.IndexNumber >= filter.MinParentAndIndexNumber.Value.IndexNumber) || e.ParentIndexNumber > filter.MinParentAndIndexNumber.Value.ParentIndexNumber);
+        }
+
+        if (filter.MinDateCreated.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.DateCreated >= filter.MinDateCreated);
+        }
+
+        if (filter.MinDateLastSaved.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSaved.Value);
+        }
+
+        if (filter.MinDateLastSavedForUser.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSavedForUser.Value);
+        }
+
+        if (filter.IndexNumber.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.IndexNumber == filter.IndexNumber.Value);
+        }
+
+        if (filter.ParentIndexNumber.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.ParentIndexNumber == filter.ParentIndexNumber.Value);
+        }
+
+        if (filter.ParentIndexNumberNotEquals.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.ParentIndexNumber != filter.ParentIndexNumberNotEquals.Value || e.ParentIndexNumber == null);
+        }
+
+        var minEndDate = filter.MinEndDate;
+        var maxEndDate = filter.MaxEndDate;
+
+        if (filter.HasAired.HasValue)
+        {
+            if (filter.HasAired.Value)
+            {
+                maxEndDate = DateTime.UtcNow;
+            }
+            else
+            {
+                minEndDate = DateTime.UtcNow;
+            }
+        }
+
+        if (minEndDate.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.EndDate >= minEndDate);
+        }
+
+        if (maxEndDate.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.EndDate <= maxEndDate);
+        }
+
+        if (filter.MinStartDate.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.StartDate >= filter.MinStartDate.Value);
+        }
+
+        if (filter.MaxStartDate.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.StartDate <= filter.MaxStartDate.Value);
+        }
+
+        if (filter.MinPremiereDate.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.PremiereDate >= filter.MinPremiereDate.Value);
+        }
+
+        if (filter.MaxPremiereDate.HasValue)
+        {
+            baseQuery = baseQuery.Where(e => e.PremiereDate <= filter.MaxPremiereDate.Value);
+        }
+
+        if (filter.TrailerTypes.Length > 0)
+        {
+            var trailerTypes = filter.TrailerTypes.Select(e => (int)e).ToArray();
+            baseQuery = baseQuery.Where(e => e.TrailerTypes!.Any(w => trailerTypes.Contains(w.Id)));
+        }
+
+        if (filter.IsAiring.HasValue)
+        {
+            if (filter.IsAiring.Value)
+            {
+                baseQuery = baseQuery.Where(e => e.StartDate <= now && e.EndDate >= now);
+            }
+            else
+            {
+                baseQuery = baseQuery.Where(e => e.StartDate > now && e.EndDate < now);
+            }
+        }
+
+        if (filter.PersonIds.Length > 0)
+        {
+            var peopleEntityIds = context.BaseItems
+                .WhereOneOrMany(filter.PersonIds, b => b.Id)
+                .Join(
+                    context.Peoples,
+                    b => b.Name,
+                    p => p.Name,
+                    (b, p) => p.Id);
+
+            baseQuery = baseQuery
+                .Where(e => context.PeopleBaseItemMap
+                    .Any(m => m.ItemId == e.Id && peopleEntityIds.Contains(m.PeopleId)));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.Person))
+        {
+            baseQuery = baseQuery.Where(e => e.Peoples!.Any(f => f.People.Name == filter.Person));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.MinSortName))
+        {
+            // this does not makes sense.
+            // baseQuery = baseQuery.Where(e => e.SortName >= query.MinSortName);
+            // whereClauses.Add("SortName>=@MinSortName");
+            // statement?.TryBind("@MinSortName", query.MinSortName);
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.ExternalSeriesId))
+        {
+            baseQuery = baseQuery.Where(e => e.ExternalSeriesId == filter.ExternalSeriesId);
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.ExternalId))
+        {
+            baseQuery = baseQuery.Where(e => e.ExternalId == filter.ExternalId);
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.Name))
+        {
+            if (filter.UseRawName == true)
+            {
+                baseQuery = baseQuery.Where(e => e.Name == filter.Name);
+            }
+            else
+            {
+                var cleanName = filter.Name.GetCleanValue();
+                baseQuery = baseQuery.Where(e => e.CleanName == cleanName);
+            }
+        }
+
+        // These are the same, for now
+        var nameContains = filter.NameContains;
+        if (!string.IsNullOrWhiteSpace(nameContains))
+        {
+            if (SearchWildcardTerms.Any(f => nameContains.Contains(f)))
+            {
+                nameContains = $"%{nameContains.Trim('%')}%";
+                baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName, nameContains) || EF.Functions.Like(e.OriginalTitle, nameContains));
+            }
+            else
+            {
+                var likeNameContains = $"%{nameContains}%";
+                baseQuery = baseQuery.Where(e =>
+                                    e.CleanName!.Contains(nameContains)
+                                    || EF.Functions.Like(e.OriginalTitle, likeNameContains));
+            }
+        }
+
+        // When box set collapsing is active, defer name-range filters to after the collapse.
+        // Otherwise, items are filtered by their own name but then collapsed into a BoxSet
+        // whose name may fall in a different range (e.g. "21 Jump Street" is under "#"
+        // but its BoxSet "Jump Street Collection" should appear under "J").
+        if (filter.CollapseBoxSetItems != true)
+        {
+            baseQuery = ApplyNameFilters(baseQuery, filter);
+        }
+
+        if (filter.ImageTypes.Length > 0)
+        {
+            var imgTypes = filter.ImageTypes.Select(e => (ImageInfoImageType)e).ToArray();
+            baseQuery = baseQuery.Where(e => e.Images!.Any(w => imgTypes.Contains(w.ImageType)));
+        }
+
+        if (filter.IsLiked.HasValue)
+        {
+            var isLiked = filter.IsLiked.Value;
+            baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.Rating >= UserItemData.MinLikeValue) == isLiked);
+        }
+
+        if (filter.IsFavoriteOrLiked.HasValue)
+        {
+            var isFavoriteOrLiked = filter.IsFavoriteOrLiked.Value;
+            baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.IsFavorite) == isFavoriteOrLiked);
+        }
+
+        if (filter.IsFavorite.HasValue)
+        {
+            var isFavorite = filter.IsFavorite.Value;
+            baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.IsFavorite) == isFavorite);
+        }
+
+        if (filter.IsPlayed.HasValue)
+        {
+            // We should probably figure this out for all folders, but for right now, this is the only place where we need it
+            if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.Series)
+            {
+                // Get played series IDs by joining episodes to UserData via SeriesId (Guid foreign key).
+                // Don't filter episodes by TopParentIds here - the series will be filtered by baseQuery anyway.
+                // This allows the materialized list to be reused across library-scoped queries.
+                var playedSeriesIdList = context.BaseItems
+                    .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue)
+                    .Join(
+                        context.UserData.Where(ud => ud.UserId == filter.User!.Id && ud.Played),
+                        episode => episode.Id,
+                        ud => ud.ItemId,
+                        (episode, ud) => episode.SeriesId!.Value)
+                    .Distinct();
+
+                var isPlayed = filter.IsPlayed.Value;
+                baseQuery = baseQuery.Where(s => playedSeriesIdList.Contains(s.Id) == isPlayed);
+            }
+            else if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.BoxSet)
+            {
+                var boxSetIds = baseQuery.Select(e => e.Id).ToList();
+                var playedCounts = GetPlayedAndTotalCountBatch(boxSetIds, filter.User!);
+                var playedBoxSetIds = playedCounts
+                    .Where(kvp => kvp.Value.Total > 0 && kvp.Value.Played == kvp.Value.Total)
+                    .Select(kvp => kvp.Key);
+
+                var isPlayedBoxSet = filter.IsPlayed.Value;
+                baseQuery = baseQuery.Where(s => playedBoxSetIds.Contains(s.Id) == isPlayedBoxSet);
+            }
+            else
+            {
+                var playedItemIds = context.UserData
+                    .Where(ud => ud.UserId == filter.User!.Id && ud.Played)
+                    .Select(ud => ud.ItemId);
+                var isPlayedItem = filter.IsPlayed.Value;
+                baseQuery = baseQuery.Where(e => playedItemIds.Contains(e.Id) == isPlayedItem);
+            }
+        }
+
+        if (filter.IsResumable.HasValue)
+        {
+            var resumableItemIds = context.UserData
+                .Where(ud => ud.UserId == filter.User!.Id && ud.PlaybackPositionTicks > 0)
+                .Select(ud => ud.ItemId);
+            var isResumable = filter.IsResumable.Value;
+            baseQuery = baseQuery.Where(e => resumableItemIds.Contains(e.Id) == isResumable);
+        }
+
+        if (filter.ArtistIds.Length > 0)
+        {
+            baseQuery = baseQuery.WhereReferencedItemMultipleTypes(context, [ItemValueType.Artist, ItemValueType.AlbumArtist], filter.ArtistIds);
+        }
+
+        if (filter.AlbumArtistIds.Length > 0)
+        {
+            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.AlbumArtist, filter.AlbumArtistIds);
+        }
+
+        if (filter.ContributingArtistIds.Length > 0)
+        {
+            var contributingNames = context.BaseItems
+                .Where(b => filter.ContributingArtistIds.Contains(b.Id))
+                .Select(b => b.CleanName);
+
+            baseQuery = baseQuery.Where(e =>
+                e.ItemValues!.Any(ivm =>
+                    ivm.ItemValue.Type == ItemValueType.Artist &&
+                    contributingNames.Contains(ivm.ItemValue.CleanValue))
+                &&
+                !e.ItemValues!.Any(ivm =>
+                    ivm.ItemValue.Type == ItemValueType.AlbumArtist &&
+                    contributingNames.Contains(ivm.ItemValue.CleanValue)));
+        }
+
+        if (filter.AlbumIds.Length > 0)
+        {
+            var subQuery = context.BaseItems.WhereOneOrMany(filter.AlbumIds, f => f.Id);
+            baseQuery = baseQuery.Where(e => subQuery.Any(f => f.Name == e.Album));
+        }
+
+        if (filter.ExcludeArtistIds.Length > 0)
+        {
+            baseQuery = baseQuery.WhereReferencedItemMultipleTypes(context, [ItemValueType.Artist, ItemValueType.AlbumArtist], filter.ExcludeArtistIds, true);
+        }
+
+        if (filter.GenreIds.Count > 0)
+        {
+            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Genre, filter.GenreIds.ToArray());
+        }
+
+        if (filter.Genres.Count > 0)
+        {
+            var cleanGenres = filter.Genres.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueMap, string>(f => f.ItemValue.CleanValue);
+            baseQuery = baseQuery
+                    .Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Genre).Any(cleanGenres));
+        }
+
+        if (tags.Count > 0)
+        {
+            var cleanValues = tags.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueMap, string>(f => f.ItemValue.CleanValue);
+            baseQuery = baseQuery
+                    .Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(cleanValues));
+        }
+
+        if (excludeTags.Count > 0)
+        {
+            var cleanValues = excludeTags.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueMap, string>(f => f.ItemValue.CleanValue);
+            baseQuery = baseQuery
+                    .Where(e => !e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(cleanValues));
+        }
+
+        if (filter.StudioIds.Length > 0)
+        {
+            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Studios, filter.StudioIds.ToArray());
+        }
+
+        if (filter.OfficialRatings.Length > 0)
+        {
+            var ratings = filter.OfficialRatings;
+            baseQuery = baseQuery.WhereItemOrDescendantMatches(context, e => ratings.Contains(e.OfficialRating));
+        }
+
+        Expression<Func<BaseItemEntity, bool>>? minParentalRatingFilter = null;
+        if (filter.MinParentalRating != null)
+        {
+            var min = filter.MinParentalRating;
+            var minScore = min.Score;
+            var minSubScore = min.SubScore ?? 0;
+
+            minParentalRatingFilter = e =>
+                e.InheritedParentalRatingValue == null ||
+                e.InheritedParentalRatingValue > minScore ||
+                (e.InheritedParentalRatingValue == minScore && (e.InheritedParentalRatingSubValue ?? 0) >= minSubScore);
+        }
+
+        Expression<Func<BaseItemEntity, bool>>? maxParentalRatingFilter = null;
+        if (filter.MaxParentalRating != null)
+        {
+            maxParentalRatingFilter = BuildMaxParentalRatingFilter(context, filter.MaxParentalRating);
+        }
+
+        if (filter.HasParentalRating ?? false)
+        {
+            if (minParentalRatingFilter != null)
+            {
+                baseQuery = baseQuery.Where(minParentalRatingFilter);
+            }
+
+            if (maxParentalRatingFilter != null)
+            {
+                baseQuery = baseQuery.Where(maxParentalRatingFilter);
+            }
+        }
+        else if (filter.BlockUnratedItems.Length > 0)
+        {
+            var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();
+            Expression<Func<BaseItemEntity, bool>> unratedItemFilter = e => e.InheritedParentalRatingValue != null || !unratedItemTypes.Contains(e.UnratedType);
+
+            if (minParentalRatingFilter != null && maxParentalRatingFilter != null)
+            {
+                baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter.And(maxParentalRatingFilter)));
+            }
+            else if (minParentalRatingFilter != null)
+            {
+                baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter));
+            }
+            else if (maxParentalRatingFilter != null)
+            {
+                baseQuery = baseQuery.Where(unratedItemFilter.And(maxParentalRatingFilter));
+            }
+            else
+            {
+                baseQuery = baseQuery.Where(unratedItemFilter);
+            }
+        }
+        else if (minParentalRatingFilter != null || maxParentalRatingFilter != null)
+        {
+            if (minParentalRatingFilter != null)
+            {
+                baseQuery = baseQuery.Where(minParentalRatingFilter);
+            }
+
+            if (maxParentalRatingFilter != null)
+            {
+                baseQuery = baseQuery.Where(maxParentalRatingFilter);
+            }
+        }
+        else if (!filter.HasParentalRating ?? false)
+        {
+            baseQuery = baseQuery
+                .Where(e => e.InheritedParentalRatingValue == null);
+        }
+
+        if (filter.HasOfficialRating.HasValue)
+        {
+            Expression<Func<BaseItemEntity, bool>> hasRating =
+                e => e.OfficialRating != null && e.OfficialRating != string.Empty;
+
+            baseQuery = filter.HasOfficialRating.Value
+                ? baseQuery.WhereItemOrDescendantMatches(context, hasRating)
+                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasRating);
+        }
+
+        if (filter.HasOverview.HasValue)
+        {
+            if (filter.HasOverview.Value)
+            {
+                baseQuery = baseQuery
+                    .Where(e => e.Overview != null && e.Overview != string.Empty);
+            }
+            else
+            {
+                baseQuery = baseQuery
+                    .Where(e => e.Overview == null || e.Overview == string.Empty);
+            }
+        }
+
+        if (filter.HasOwnerId.HasValue)
+        {
+            if (filter.HasOwnerId.Value)
+            {
+                baseQuery = baseQuery
+                    .Where(e => e.OwnerId != null);
+            }
+            else
+            {
+                baseQuery = baseQuery
+                    .Where(e => e.OwnerId == null);
+            }
+        }
+        else if (filter.OwnerIds.Length == 0 && filter.ExtraTypes.Length == 0 && !filter.IncludeOwnedItems)
+        {
+            // Exclude alternate versions from general queries. Alternate versions have
+            // OwnerId set (pointing to their primary) but no ExtraType.
+            // Extras (trailers, etc.) also have OwnerId but DO have ExtraType set - keep those.
+            baseQuery = baseQuery.Where(e => e.OwnerId == null || e.ExtraType != null);
+        }
+
+        if (filter.OwnerIds.Length > 0)
+        {
+            baseQuery = baseQuery.Where(e => e.OwnerId != null && filter.OwnerIds.Contains(e.OwnerId.Value));
+        }
+
+        if (filter.ExtraTypes.Length > 0)
+        {
+            // Convert ExtraType enum to BaseItemExtraType enum via int cast (same underlying values)
+            var extraTypeValues = filter.ExtraTypes.Select(e => (BaseItemExtraType?)(int)e).ToArray();
+            baseQuery = baseQuery.Where(e => e.ExtraType != null && extraTypeValues.Contains(e.ExtraType));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.HasNoAudioTrackWithLanguage))
+        {
+            var lang = filter.HasNoAudioTrackWithLanguage;
+            var foldersWithAudio = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStreamTypeEntity.Audio, lang));
+
+            baseQuery = baseQuery
+                .Where(e =>
+                    (!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Audio && ms.Language == lang))
+                    || (e.IsFolder && !foldersWithAudio.Contains(e.Id)));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.HasNoInternalSubtitleTrackWithLanguage))
+        {
+            var lang = filter.HasNoInternalSubtitleTrackWithLanguage;
+            var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang, IsExternal: false));
+
+            baseQuery = baseQuery
+                .Where(e =>
+                    (!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && !ms.IsExternal && ms.Language == lang))
+                    || (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.HasNoExternalSubtitleTrackWithLanguage))
+        {
+            var lang = filter.HasNoExternalSubtitleTrackWithLanguage;
+            var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang, IsExternal: true));
+
+            baseQuery = baseQuery
+                .Where(e =>
+                    (!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && ms.IsExternal && ms.Language == lang))
+                    || (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.HasNoSubtitleTrackWithLanguage))
+        {
+            var lang = filter.HasNoSubtitleTrackWithLanguage;
+            var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang));
+
+            baseQuery = baseQuery
+                .Where(e =>
+                    (!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && ms.Language == lang))
+                    || (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));
+        }
+
+        if (filter.HasSubtitles.HasValue)
+        {
+            var hasSubtitles = filter.HasSubtitles.Value;
+            var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasSubtitles());
+            if (hasSubtitles)
+            {
+                baseQuery = baseQuery
+                    .Where(e =>
+                        (!e.IsFolder && e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle))
+                        || (e.IsFolder && foldersWithSubtitles.Contains(e.Id)));
+            }
+            else
+            {
+                baseQuery = baseQuery
+                    .Where(e =>
+                        (!e.IsFolder && !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle))
+                        || (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));
+            }
+        }
+
+        if (filter.HasChapterImages.HasValue)
+        {
+            var hasChapterImages = filter.HasChapterImages.Value;
+            var foldersWithChapterImages = DescendantQueryHelper.GetFolderIdsMatching(context, new HasChapterImages());
+            if (hasChapterImages)
+            {
+                baseQuery = baseQuery
+                    .Where(e =>
+                        (!e.IsFolder && e.Chapters!.Any(f => f.ImagePath != null))
+                        || (e.IsFolder && foldersWithChapterImages.Contains(e.Id)));
+            }
+            else
+            {
+                baseQuery = baseQuery
+                    .Where(e =>
+                        (!e.IsFolder && !e.Chapters!.Any(f => f.ImagePath != null))
+                        || (e.IsFolder && !foldersWithChapterImages.Contains(e.Id)));
+            }
+        }
+
+        if (filter.HasDeadParentId.HasValue && filter.HasDeadParentId.Value)
+        {
+            baseQuery = baseQuery
+                .Where(e => e.ParentId.HasValue && !context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Any(f => f.Id == e.ParentId.Value));
+        }
+
+        if (filter.IsDeadArtist.HasValue && filter.IsDeadArtist.Value)
+        {
+            baseQuery = baseQuery
+                    .Where(e => !context.ItemValues.Where(f => _getAllArtistsValueTypes.Contains(f.Type)).Any(f => f.Value == e.Name));
+        }
+
+        if (filter.IsDeadStudio.HasValue && filter.IsDeadStudio.Value)
+        {
+            baseQuery = baseQuery
+                    .Where(e => !context.ItemValues.Where(f => _getStudiosValueTypes.Contains(f.Type)).Any(f => f.Value == e.Name));
+        }
+
+        if (filter.IsDeadGenre.HasValue && filter.IsDeadGenre.Value)
+        {
+            baseQuery = baseQuery
+                    .Where(e => !context.ItemValues.Where(f => _getGenreValueTypes.Contains(f.Type)).Any(f => f.Value == e.Name));
+        }
+
+        if (filter.IsDeadPerson.HasValue && filter.IsDeadPerson.Value)
+        {
+            baseQuery = baseQuery
+                .Where(e => !context.Peoples.Any(f => f.Name == e.Name));
+        }
+
+        if (filter.Years.Length > 0)
+        {
+            baseQuery = baseQuery.WhereOneOrMany(filter.Years, e => e.ProductionYear!.Value);
+        }
+
+        var isVirtualItem = filter.IsVirtualItem ?? filter.IsMissing;
+        if (isVirtualItem.HasValue)
+        {
+            baseQuery = baseQuery
+                .Where(e => e.IsVirtualItem == isVirtualItem.Value);
+        }
+
+        if (filter.IsSpecialSeason.HasValue)
+        {
+            if (filter.IsSpecialSeason.Value)
+            {
+                baseQuery = baseQuery
+                    .Where(e => e.IndexNumber == 0);
+            }
+            else
+            {
+                baseQuery = baseQuery
+                    .Where(e => e.IndexNumber != 0);
+            }
+        }
+
+        if (filter.IsUnaired.HasValue)
+        {
+            if (filter.IsUnaired.Value)
+            {
+                baseQuery = baseQuery
+                    .Where(e => e.PremiereDate >= now);
+            }
+            else
+            {
+                baseQuery = baseQuery
+                    .Where(e => e.PremiereDate < now);
+            }
+        }
+
+        if (filter.MediaTypes.Length > 0)
+        {
+            var mediaTypes = filter.MediaTypes.Select(f => f.ToString()).ToArray();
+            baseQuery = baseQuery.WhereOneOrMany(mediaTypes, e => e.MediaType);
+        }
+
+        if (filter.ItemIds.Length > 0)
+        {
+            baseQuery = baseQuery.WhereOneOrMany(filter.ItemIds, e => e.Id);
+        }
+
+        if (filter.ExcludeItemIds.Length > 0)
+        {
+            baseQuery = baseQuery
+                .Where(e => !filter.ExcludeItemIds.Contains(e.Id));
+        }
+
+        if (filter.ExcludeProviderIds is not null && filter.ExcludeProviderIds.Count > 0)
+        {
+            var exclude = filter.ExcludeProviderIds.Select(e => $"{e.Key}:{e.Value}").ToArray();
+            baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.All(f => !exclude.Contains(f)));
+        }
+
+        if (filter.HasAnyProviderId is not null && filter.HasAnyProviderId.Count > 0)
+        {
+            // Allow setting a null or empty value to get all items that have the specified provider set.
+            var includeAny = filter.HasAnyProviderId.Where(e => string.IsNullOrEmpty(e.Value)).Select(e => e.Key).ToArray();
+            if (includeAny.Length > 0)
+            {
+                baseQuery = baseQuery.Where(e => e.Provider!.Any(f => includeAny.Contains(f.ProviderId)));
+            }
+
+            var includeSelected = filter.HasAnyProviderId.Where(e => !string.IsNullOrEmpty(e.Value)).Select(e => $"{e.Key}:{e.Value}").ToArray();
+            if (includeSelected.Length > 0)
+            {
+                baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.Any(f => includeSelected.Contains(f)));
+            }
+        }
+
+        if (filter.HasImdbId.HasValue)
+        {
+            baseQuery = filter.HasImdbId.Value
+                ? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == ImdbProviderName))
+                : baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != ImdbProviderName));
+        }
+
+        if (filter.HasTmdbId.HasValue)
+        {
+            baseQuery = filter.HasTmdbId.Value
+                ? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == TmdbProviderName))
+                : baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != TmdbProviderName));
+        }
+
+        if (filter.HasTvdbId.HasValue)
+        {
+            baseQuery = filter.HasTvdbId.Value
+                ? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == TvdbProviderName))
+                : baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != TvdbProviderName));
+        }
+
+        var queryTopParentIds = filter.TopParentIds;
+
+        if (queryTopParentIds.Length > 0)
+        {
+            var includedItemByNameTypes = GetItemByNameTypesInQuery(filter);
+            var enableItemsByName = (filter.IncludeItemsByName ?? false) && includedItemByNameTypes.Count > 0;
+            if (enableItemsByName && includedItemByNameTypes.Count > 0)
+            {
+                baseQuery = baseQuery.Where(e => includedItemByNameTypes.Contains(e.Type) || queryTopParentIds.Any(w => w == e.TopParentId!.Value));
+            }
+            else
+            {
+                baseQuery = baseQuery.WhereOneOrMany(queryTopParentIds, e => e.TopParentId!.Value);
+            }
+        }
+
+        if (filter.AncestorIds.Length > 0)
+        {
+            var ancestorFilter = filter.AncestorIds.OneOrManyExpressionBuilder<AncestorId, Guid>(f => f.ParentItemId);
+            baseQuery = baseQuery.Where(e => e.Parents!.AsQueryable().Any(ancestorFilter));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.AncestorWithPresentationUniqueKey))
+        {
+            baseQuery = baseQuery
+                .Where(e => context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Where(f => f.PresentationUniqueKey == filter.AncestorWithPresentationUniqueKey).Any(f => f.Children!.Any(w => w.ItemId == e.Id)));
+        }
+
+        if (!string.IsNullOrWhiteSpace(filter.SeriesPresentationUniqueKey))
+        {
+            baseQuery = baseQuery
+                .Where(e => e.SeriesPresentationUniqueKey == filter.SeriesPresentationUniqueKey);
+        }
+
+        if (filter.ExcludeInheritedTags.Length > 0)
+        {
+            var excludedTags = filter.ExcludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();
+            baseQuery = baseQuery.Where(e =>
+                !context.ItemValuesMap.Any(f =>
+                    f.ItemValue.Type == ItemValueType.Tags
+                    && excludedTags.Contains(f.ItemValue.CleanValue)
+                    && (f.ItemId == e.Id
+                        || (e.SeriesId.HasValue && f.ItemId == e.SeriesId.Value)
+                        || e.Parents!.Any(p => f.ItemId == p.ParentItemId)
+                        || (e.TopParentId.HasValue && f.ItemId == e.TopParentId.Value))));
+        }
+
+        if (filter.IncludeInheritedTags.Length > 0)
+        {
+            var includeTags = filter.IncludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();
+            var isPlaylistOnlyQuery = includeTypes.Length == 1 && includeTypes.FirstOrDefault() == BaseItemKind.Playlist;
+            baseQuery = baseQuery.Where(e =>
+                context.ItemValuesMap.Any(f =>
+                    f.ItemValue.Type == ItemValueType.Tags
+                    && includeTags.Contains(f.ItemValue.CleanValue)
+                    && (f.ItemId == e.Id
+                        || (e.SeriesId.HasValue && f.ItemId == e.SeriesId.Value)
+                        || e.Parents!.Any(p => f.ItemId == p.ParentItemId)
+                        || (e.TopParentId.HasValue && f.ItemId == e.TopParentId.Value)))
+
+                // A playlist should be accessible to its owner regardless of allowed tags
+                || (isPlaylistOnlyQuery && e.Data!.Contains($"OwnerUserId\":\"{filter.User!.Id:N}\"")));
+        }
+
+        if (filter.SeriesStatuses.Length > 0)
+        {
+            var seriesStatus = filter.SeriesStatuses.Select(e => e.ToString()).ToArray();
+            baseQuery = baseQuery
+                .Where(e => seriesStatus.Any(f => e.Data!.Contains(f)));
+        }
+
+        if (filter.BoxSetLibraryFolders.Length > 0)
+        {
+            var boxsetFolders = filter.BoxSetLibraryFolders.Select(e => e.ToString("N", CultureInfo.InvariantCulture)).ToArray();
+            baseQuery = baseQuery
+                .Where(e => boxsetFolders.Any(f => e.Data!.Contains(f)));
+        }
+
+        if (filter.VideoTypes.Length > 0)
+        {
+            var videoTypeBs = filter.VideoTypes.Select(vt => $"\"VideoType\":\"{vt}\"").ToArray();
+            Expression<Func<BaseItemEntity, bool>> hasVideoType = e => videoTypeBs.Any(f => e.Data!.Contains(f));
+            baseQuery = baseQuery.WhereItemOrDescendantMatches(context, hasVideoType);
+        }
+
+        if (filter.Is3D.HasValue)
+        {
+            Expression<Func<BaseItemEntity, bool>> is3D = e => e.Data!.Contains("Video3DFormat");
+
+            baseQuery = filter.Is3D.Value
+                ? baseQuery.WhereItemOrDescendantMatches(context, is3D)
+                : baseQuery.WhereNeitherItemNorDescendantMatches(context, is3D);
+        }
+
+        if (filter.IsPlaceHolder.HasValue)
+        {
+            Expression<Func<BaseItemEntity, bool>> isPlaceHolder = e => e.Data!.Contains("IsPlaceHolder\":true");
+
+            baseQuery = filter.IsPlaceHolder.Value
+                ? baseQuery.WhereItemOrDescendantMatches(context, isPlaceHolder)
+                : baseQuery.WhereNeitherItemNorDescendantMatches(context, isPlaceHolder);
+        }
+
+        if (filter.HasSpecialFeature.HasValue)
+        {
+            var itemsWithExtras = context.BaseItems
+                .Where(extra => extra.OwnerId != null
+                    && extra.ExtraType != null
+                    && extra.ExtraType != BaseItemExtraType.Unknown
+                    && extra.ExtraType != BaseItemExtraType.Trailer
+                    && extra.ExtraType != BaseItemExtraType.ThemeSong
+                    && extra.ExtraType != BaseItemExtraType.ThemeVideo)
+                .Select(extra => extra.OwnerId!.Value)
+                .Distinct();
+
+            Expression<Func<BaseItemEntity, bool>> hasExtras = e => itemsWithExtras.Contains(e.Id);
+
+            baseQuery = filter.HasSpecialFeature.Value
+                ? baseQuery.WhereItemOrDescendantMatches(context, hasExtras)
+                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasExtras);
+        }
+
+        if (filter.HasTrailer.HasValue)
+        {
+            var trailerOwnerIds = context.BaseItems
+                .Where(extra => extra.ExtraType == BaseItemExtraType.Trailer && extra.OwnerId != null)
+                .Select(extra => extra.OwnerId!.Value);
+
+            Expression<Func<BaseItemEntity, bool>> hasTrailer = e => trailerOwnerIds.Contains(e.Id);
+
+            baseQuery = filter.HasTrailer.Value
+                ? baseQuery.WhereItemOrDescendantMatches(context, hasTrailer)
+                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasTrailer);
+        }
+
+        if (filter.HasThemeSong.HasValue)
+        {
+            var themeSongOwnerIds = context.BaseItems
+                .Where(extra => extra.ExtraType == BaseItemExtraType.ThemeSong && extra.OwnerId != null)
+                .Select(extra => extra.OwnerId!.Value);
+
+            Expression<Func<BaseItemEntity, bool>> hasThemeSong = e => themeSongOwnerIds.Contains(e.Id);
+
+            baseQuery = filter.HasThemeSong.Value
+                ? baseQuery.WhereItemOrDescendantMatches(context, hasThemeSong)
+                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasThemeSong);
+        }
+
+        if (filter.HasThemeVideo.HasValue)
+        {
+            var themeVideoOwnerIds = context.BaseItems
+                .Where(extra => extra.ExtraType == BaseItemExtraType.ThemeVideo && extra.OwnerId != null)
+                .Select(extra => extra.OwnerId!.Value);
+
+            Expression<Func<BaseItemEntity, bool>> hasThemeVideo = e => themeVideoOwnerIds.Contains(e.Id);
+
+            baseQuery = filter.HasThemeVideo.Value
+                ? baseQuery.WhereItemOrDescendantMatches(context, hasThemeVideo)
+                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasThemeVideo);
+        }
+
+        if (filter.AiredDuringSeason.HasValue)
+        {
+            var seasonNumber = filter.AiredDuringSeason.Value;
+            if (seasonNumber < 1)
+            {
+                baseQuery = baseQuery.Where(e => e.ParentIndexNumber == seasonNumber);
+            }
+            else
+            {
+                var seasonStr = seasonNumber.ToString(CultureInfo.InvariantCulture);
+                baseQuery = baseQuery.Where(e =>
+                    e.ParentIndexNumber == seasonNumber
+                    || (e.Data != null && (
+                        e.Data.Contains("\"AirsAfterSeasonNumber\":" + seasonStr)
+                        || e.Data.Contains("\"AirsBeforeSeasonNumber\":" + seasonStr))));
+            }
+        }
+
+        if (filter.AdjacentTo.HasValue && !filter.AdjacentTo.Value.IsEmpty())
+        {
+            var adjacentToId = filter.AdjacentTo.Value;
+            var targetItem = context.BaseItems.Where(e => e.Id == adjacentToId).Select(e => new { e.SortName, e.Id }).FirstOrDefault();
+            if (targetItem is not null)
+            {
+                var targetSortName = targetItem.SortName ?? string.Empty;
+
+                // Fetch both prev and next adjacent items in a single query using Concat (UNION ALL).
+                var adjacentIds = context.BaseItems
+                    .Where(e => string.Compare(e.SortName, targetSortName) < 0)
+                    .OrderByDescending(e => e.SortName)
+                    .Select(e => e.Id)
+                    .Take(1)
+                    .Concat(
+                        context.BaseItems
+                            .Where(e => string.Compare(e.SortName, targetSortName) > 0)
+                            .OrderBy(e => e.SortName)
+                            .Select(e => e.Id)
+                            .Take(1))
+                    .ToList();
+
+                adjacentIds.Add(adjacentToId);
+                baseQuery = baseQuery.Where(e => adjacentIds.Contains(e.Id));
+            }
+        }
+
+        return baseQuery;
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 23a426ac58..94dedaeba8 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -1,49 +1,19 @@
-#pragma warning disable RS0030 // Do not use banned APIs
-// Do not enforce that because EFCore cannot deal with cultures well.
-#pragma warning disable CA1304 // Specify CultureInfo
-#pragma warning disable CA1309 // Use ordinal string comparison
-#pragma warning disable CA1311 // Specify a culture or use an invariant version
-#pragma warning disable CA1862 // Use the 'StringComparison' method overloads to perform case-insensitive string comparisons
-
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
-using System.Globalization;
 using System.Linq;
-using System.Linq.Expressions;
-using System.Reflection;
-using System.Text;
-using System.Text.Json;
-using System.Threading;
-using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Enums;
-using Jellyfin.Database.Implementations.MatchCriteria;
 using Jellyfin.Extensions;
-using Jellyfin.Extensions.Json;
-using Jellyfin.Server.Implementations.Extensions;
-using MediaBrowser.Common;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Channels;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Entities.Audio;
-using MediaBrowser.Controller.Entities.TV;
-using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.Persistence;
-using MediaBrowser.Controller.Playlists;
-using MediaBrowser.Model.Dto;
-using MediaBrowser.Model.Entities;
-using MediaBrowser.Model.LiveTv;
-using MediaBrowser.Model.Querying;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;
 using BaseItemEntity = Jellyfin.Database.Implementations.Entities.BaseItemEntity;
-using DbLinkedChildType = Jellyfin.Database.Implementations.Entities.LinkedChildType;
-using LinkedChildType = MediaBrowser.Controller.Entities.LinkedChildType;
 
 namespace Jellyfin.Server.Implementations.Item;
 
@@ -56,19 +26,14 @@ namespace Jellyfin.Server.Implementations.Item;
 /// <summary>
 /// Handles all storage logic for BaseItems.
 /// </summary>
-public sealed class BaseItemRepository
-    : IItemRepository
+public sealed partial class BaseItemRepository
+    : IItemRepository, IItemQueryHelpers
 {
     /// <summary>
     /// Gets the placeholder id for UserData detached items.
     /// </summary>
     public static readonly Guid PlaceholderId = Guid.Parse("00000000-0000-0000-0000-000000000001");
 
-    /// <summary>
-    /// This holds all the types in the running assemblies
-    /// so that we can de-serialize properly when we don't have strong types.
-    /// </summary>
-    private static readonly ConcurrentDictionary<string, Type?> _typeMap = new ConcurrentDictionary<string, Type?>();
     private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
     private readonly IServerApplicationHost _appHost;
     private readonly IItemTypeLookup _itemTypeLookup;
@@ -80,11 +45,6 @@ public sealed class BaseItemRepository
     private static readonly IReadOnlyList<ItemValueType> _getAlbumArtistValueTypes = [ItemValueType.AlbumArtist];
     private static readonly IReadOnlyList<ItemValueType> _getStudiosValueTypes = [ItemValueType.Studios];
     private static readonly IReadOnlyList<ItemValueType> _getGenreValueTypes = [ItemValueType.Genre];
-    private static readonly IReadOnlyList<char> SearchWildcardTerms = ['%', '_', '[', ']', '^'];
-
-    private static readonly string ImdbProviderName = MetadataProvider.Imdb.ToString().ToLowerInvariant();
-    private static readonly string TmdbProviderName = MetadataProvider.Tmdb.ToString().ToLowerInvariant();
-    private static readonly string TvdbProviderName = MetadataProvider.Tvdb.ToString().ToLowerInvariant();
 
     /// <summary>
     /// Initializes a new instance of the <see cref="BaseItemRepository"/> class.
@@ -108,4368 +68,167 @@ public sealed class BaseItemRepository
         _logger = logger;
     }
 
-    /// <inheritdoc />
-    public void DeleteItem(params IReadOnlyList<Guid> ids)
-    {
-        if (ids is null || ids.Count == 0 || ids.Any(f => f.Equals(PlaceholderId)))
-        {
-            throw new ArgumentException("Guid can't be empty or the placeholder id.", nameof(ids));
-        }
-
-        using var context = _dbProvider.CreateDbContext();
-        using var transaction = context.Database.BeginTransaction();
-
-        var date = (DateTime?)DateTime.UtcNow;
-
-        // Use owned-only traversal (AncestorIds) to avoid deleting items that are merely
-        // linked via LinkedChildren (e.g. movies/series inside a BoxSet are associations, not owned children).
-        var descendantIds = DescendantQueryHelper.GetOwnedDescendantIdsBatch(context, ids);
-        foreach (var id in ids)
-        {
-            descendantIds.Add(id);
-        }
-
-        var extraIds = context.BaseItems
-            .Where(e => e.OwnerId.HasValue && descendantIds.Contains(e.OwnerId.Value))
-            .Select(e => e.Id)
-            .ToArray();
-
-        foreach (var extraId in extraIds)
-        {
-            descendantIds.Add(extraId);
-        }
-
-        var relatedItems = descendantIds.ToArray();
-
-        // Remove any UserData entries for the placeholder item that would conflict with the UserData
-        // being detached from the item being deleted. This is necessary because, during an update,
-        // UserData may be reattached to a new entry, but some entries can be left behind.
-        // Ensures there are no duplicate UserId/CustomDataKey combinations for the placeholder.
-        context.UserData
-            .Join(
-                context.UserData.WhereOneOrMany(relatedItems, e => e.ItemId),
-                placeholder => new { placeholder.UserId, placeholder.CustomDataKey },
-                userData => new { userData.UserId, userData.CustomDataKey },
-                (placeholder, userData) => placeholder)
-            .Where(e => e.ItemId == PlaceholderId)
-            .ExecuteDelete();
-
-        // Detach all user watch data
-        context.UserData.WhereOneOrMany(relatedItems, e => e.ItemId)
-            .ExecuteUpdate(e => e
-                .SetProperty(f => f.RetentionDate, date)
-                .SetProperty(f => f.ItemId, PlaceholderId));
-
-        context.AncestorIds.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.AncestorIds.WhereOneOrMany(relatedItems, e => e.ParentItemId).ExecuteDelete();
-        context.AttachmentStreamInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.BaseItemImageInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.BaseItemMetadataFields.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.BaseItemProviders.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.BaseItemTrailerTypes.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.Chapters.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.CustomItemDisplayPreferences.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.ItemDisplayPreferences.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.ItemValues.Where(e => e.BaseItemsMap!.Count == 0).ExecuteDelete();
-        context.ItemValuesMap.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.LinkedChildren.WhereOneOrMany(relatedItems, e => e.ParentId).ExecuteDelete();
-        context.LinkedChildren.WhereOneOrMany(relatedItems, e => e.ChildId).ExecuteDelete();
-        context.BaseItems.WhereOneOrMany(relatedItems, e => e.Id).ExecuteDelete();
-        context.KeyframeData.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.MediaSegments.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.MediaStreamInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        var query = context.PeopleBaseItemMap.WhereOneOrMany(relatedItems, e => e.ItemId).Select(f => f.PeopleId).Distinct().ToArray();
-        context.PeopleBaseItemMap.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.Peoples.WhereOneOrMany(query, e => e.Id).Where(e => e.BaseItems!.Count == 0).ExecuteDelete();
-        context.TrickplayInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
-        context.SaveChanges();
-        transaction.Commit();
-    }
-
-    /// <inheritdoc />
-    public void UpdateInheritedValues()
-    {
-        using var context = _dbProvider.CreateDbContext();
-        using var transaction = context.Database.BeginTransaction();
-
-        context.ItemValuesMap.Where(e => e.ItemValue.Type == ItemValueType.InheritedTags).ExecuteDelete();
-        // ItemValue Inheritance is now correctly mapped via AncestorId on demand
-        context.SaveChanges();
-
-        transaction.Commit();
-    }
-
-    /// <inheritdoc />
-    public IReadOnlyList<Guid> GetItemIdsList(InternalItemsQuery filter)
-    {
-        ArgumentNullException.ThrowIfNull(filter);
-        PrepareFilterQuery(filter);
-
-        using var context = _dbProvider.CreateDbContext();
-        return ApplyQueryFilter(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId)), context, filter).Select(e => e.Id).ToArray();
-    }
-
-    /// <inheritdoc />
-    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAllArtists(InternalItemsQuery filter)
-    {
-        return GetItemValues(filter, _getAllArtistsValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);
-    }
-
-    /// <inheritdoc />
-    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetArtists(InternalItemsQuery filter)
-    {
-        return GetItemValues(filter, _getArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);
-    }
-
-    /// <inheritdoc />
-    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetAlbumArtists(InternalItemsQuery filter)
-    {
-        return GetItemValues(filter, _getAlbumArtistValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]);
-    }
-
-    /// <inheritdoc />
-    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetStudios(InternalItemsQuery filter)
-    {
-        return GetItemValues(filter, _getStudiosValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]);
-    }
-
-    /// <inheritdoc />
-    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetGenres(InternalItemsQuery filter)
-    {
-        return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]);
-    }
-
-    /// <inheritdoc />
-    public QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetMusicGenres(InternalItemsQuery filter)
-    {
-        return GetItemValues(filter, _getGenreValueTypes, _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]);
-    }
-
-    /// <inheritdoc />
-    public IReadOnlyList<string> GetStudioNames()
-    {
-        return GetItemValueNames(_getStudiosValueTypes, [], []);
-    }
-
-    /// <inheritdoc />
-    public IReadOnlyList<string> GetAllArtistNames()
+    /// <summary>
+    /// Maps a Entity to the DTO. Delegates to <see cref="BaseItemMapper"/>.
+    /// </summary>
+    /// <param name="entity">The database entity.</param>
+    /// <param name="dto">The target DTO.</param>
+    /// <param name="appHost">The application host.</param>
+    /// <param name="logger">The logger.</param>
+    /// <returns>The mapped DTO.</returns>
+    public static BaseItemDto Map(BaseItemEntity entity, BaseItemDto dto, IServerApplicationHost? appHost, ILogger logger)
     {
-        return GetItemValueNames(_getAllArtistsValueTypes, [], []);
+        return BaseItemMapper.Map(entity, dto, appHost);
     }
 
-    /// <inheritdoc />
-    public IReadOnlyList<string> GetMusicGenreNames()
+    /// <summary>
+    /// Maps a DTO to a database entity. Delegates to <see cref="BaseItemMapper"/>.
+    /// </summary>
+    /// <param name="dto">The DTO to map.</param>
+    /// <returns>The mapped database entity.</returns>
+    public BaseItemEntity Map(BaseItemDto dto)
     {
-        return GetItemValueNames(
-            _getGenreValueTypes,
-            _itemTypeLookup.MusicGenreTypes,
-            []);
+        return BaseItemMapper.Map(dto, _appHost);
     }
 
-    /// <inheritdoc />
-    public IReadOnlyList<string> GetGenreNames()
+    /// <summary>
+    /// Deserializes a BaseItemEntity and sets all properties.
+    /// </summary>
+    /// <param name="baseItemEntity">The entity to deserialize.</param>
+    /// <param name="logger">The logger.</param>
+    /// <param name="appHost">The application host.</param>
+    /// <param name="skipDeserialization">Whether to skip JSON deserialization.</param>
+    /// <returns>The deserialized item, or null.</returns>
+    public static BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost? appHost, bool skipDeserialization = false)
     {
-        return GetItemValueNames(
-            _getGenreValueTypes,
-            [],
-            _itemTypeLookup.MusicGenreTypes);
+        return BaseItemMapper.DeserializeBaseItem(baseItemEntity, logger, appHost, skipDeserialization);
     }
 
     /// <inheritdoc />
-    public QueryResult<BaseItemDto> GetItems(InternalItemsQuery filter)
+    public void PrepareFilterQuery(InternalItemsQuery query)
     {
-        ArgumentNullException.ThrowIfNull(filter);
-        if (!filter.EnableTotalRecordCount || (!filter.Limit.HasValue && (filter.StartIndex ?? 0) == 0))
+        if (query.Limit.HasValue && query.EnableGroupByMetadataKey)
         {
-            var returnList = GetItemList(filter);
-            return new QueryResult<BaseItemDto>(
-                filter.StartIndex,
-                returnList.Count,
-                returnList);
+            query.Limit = query.Limit.Value + 4;
         }
 
-        PrepareFilterQuery(filter);
-        var result = new QueryResult<BaseItemDto>();
-
-        using var context = _dbProvider.CreateDbContext();
-
-        IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);
-
-        dbQuery = TranslateQuery(dbQuery, context, filter);
-        dbQuery = ApplyGroupingFilter(context, dbQuery, filter);
-
-        if (filter.EnableTotalRecordCount)
+        if (query.IsResumable ?? false)
         {
-            result.TotalRecordCount = dbQuery.Count();
+            query.IsVirtualItem = false;
         }
-
-        dbQuery = ApplyQueryPaging(dbQuery, filter);
-        dbQuery = ApplyNavigations(dbQuery, filter);
-
-        result.Items = dbQuery.AsEnumerable().Where(e => e != null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).Where(dto => dto != null).ToArray()!;
-        result.StartIndex = filter.StartIndex ?? 0;
-        return result;
     }
 
-    /// <inheritdoc />
-    public IReadOnlyList<BaseItemDto> GetItemList(InternalItemsQuery filter)
+    private List<string> GetItemByNameTypesInQuery(InternalItemsQuery query)
     {
-        ArgumentNullException.ThrowIfNull(filter);
-        PrepareFilterQuery(filter);
-
-        using var context = _dbProvider.CreateDbContext();
-        IQueryable<BaseItemEntity> dbQuery = PrepareItemQuery(context, filter);
-
-        dbQuery = TranslateQuery(dbQuery, context, filter);
-
-        dbQuery = ApplyGroupingFilter(context, dbQuery, filter);
-        dbQuery = ApplyQueryPaging(dbQuery, filter);
+        var list = new List<string>();
 
-        var hasRandomSort = filter.OrderBy.Any(e => e.OrderBy == ItemSortBy.Random);
-        if (hasRandomSort)
+        if (IsTypeInQuery(BaseItemKind.Person, query))
         {
-            var orderedIds = dbQuery.Select(e => e.Id).ToList();
-            if (orderedIds.Count == 0)
-            {
-                return Array.Empty<BaseItemDto>();
-            }
-
-            var itemsById = ApplyNavigations(context.BaseItems.Where(e => orderedIds.Contains(e.Id)), filter)
-                .AsEnumerable()
-                .Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))
-                .Where(dto => dto != null)
-                .ToDictionary(i => i!.Id);
-
-            return orderedIds.Where(itemsById.ContainsKey).Select(id => itemsById[id]).ToArray()!;
+            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Person]!);
         }
 
-        dbQuery = ApplyNavigations(dbQuery, filter);
-
-        return dbQuery.AsEnumerable().Where(e => e != null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).Where(dto => dto != null).ToArray()!;
-    }
-
-    /// <inheritdoc/>
-    public IReadOnlyList<BaseItemDto> GetLatestItemList(InternalItemsQuery filter, CollectionType collectionType)
-    {
-        ArgumentNullException.ThrowIfNull(filter);
-        PrepareFilterQuery(filter);
-
-        // Early exit if collection type is not supported
-        if (collectionType is not CollectionType.movies and not CollectionType.tvshows and not CollectionType.music)
+        if (IsTypeInQuery(BaseItemKind.Genre, query))
         {
-            return [];
+            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]!);
         }
 
-        var limit = filter.Limit;
-        using var context = _dbProvider.CreateDbContext();
-
-        var baseQuery = PrepareItemQuery(context, filter);
-        baseQuery = TranslateQuery(baseQuery, context, filter);
-
-        if (collectionType == CollectionType.tvshows)
+        if (IsTypeInQuery(BaseItemKind.MusicGenre, query))
         {
-            return GetLatestTvShowItems(context, baseQuery, filter, limit);
+            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]!);
         }
 
-        // Find the top N group keys ordered by most recent DateCreated.
-        // Movies group by PresentationUniqueKey (alternate versions like 4K/1080p share a key).
-        // Music groups by Album.
-        Expression<Func<BaseItemEntity, bool>> groupKeyFilter;
-        Expression<Func<BaseItemEntity, string?>> groupKeySelector;
-
-        if (collectionType is CollectionType.movies)
-        {
-            groupKeyFilter = e => e.PresentationUniqueKey != null;
-            groupKeySelector = e => e.PresentationUniqueKey;
-        }
-        else
+        if (IsTypeInQuery(BaseItemKind.MusicArtist, query))
         {
-            groupKeyFilter = e => e.Album != null;
-            groupKeySelector = e => e.Album;
+            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]!);
         }
 
-        var topGroupKeys = baseQuery
-            .Where(groupKeyFilter)
-            .GroupBy(groupKeySelector)
-            .Select(g => new { GroupKey = g.Key!, MaxDate = g.Max(e => e.DateCreated) })
-            .OrderByDescending(g => g.MaxDate);
-
-        if (filter.Limit.HasValue)
+        if (IsTypeInQuery(BaseItemKind.Studio, query))
         {
-            topGroupKeys = topGroupKeys.Take(filter.Limit.Value).OrderByDescending(g => g.MaxDate);
+            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]!);
         }
 
-        // Get only the first (most recent) item ID per group using a lightweight projection,
-        // then fetch full entities only for those items. This avoids loading all versions/tracks
-        // with expensive navigation properties just to discard duplicates.
-        var topGroupKeyList = topGroupKeys.Select(g => g.GroupKey).ToList();
-        // ThenByDescending(Id) is a tiebreaker for deterministic ordering when multiple items
-        // share the same DateCreated timestamp — without it, SQL returns arbitrary order across queries.
-        var allItemsLite = collectionType switch
-        {
-            CollectionType.movies => baseQuery
-                .Where(e => e.PresentationUniqueKey != null && topGroupKeyList.Contains(e.PresentationUniqueKey))
-                .OrderByDescending(e => e.DateCreated)
-                .ThenByDescending(e => e.Id)
-                .Select(e => new { e.Id, GroupKey = e.PresentationUniqueKey })
-                .AsEnumerable(),
-            _ => baseQuery
-                .Where(e => e.Album != null && topGroupKeyList.Contains(e.Album))
-                .OrderByDescending(e => e.DateCreated)
-                .ThenByDescending(e => e.Id)
-                .Select(e => new { e.Id, GroupKey = e.Album })
-                .AsEnumerable()
-        };
-
-        // Client-side DistinctBy: EF Core/SQLite cannot reliably translate
-        // GroupBy(...).Select(g => g.First()) to SQL. The projection is lightweight
-        // (only Id + GroupKey for ~50 items), so client-side dedup is negligible.
-        var firstIds = allItemsLite
-            .DistinctBy(e => e.GroupKey)
-            .Select(e => e.Id)
-            .AsEnumerable();
-
-        var itemsQuery = context.BaseItems.AsNoTracking().Where(e => firstIds.Contains(e.Id));
-        itemsQuery = ApplyNavigations(itemsQuery, filter);
-
-        return itemsQuery
-            .OrderByDescending(e => e.DateCreated)
-            .ThenByDescending(e => e.Id)
-            .AsEnumerable()
-            .Select(w => DeserializeBaseItem(w, filter.SkipDeserialization))
-            .Where(dto => dto != null)
-            .ToArray()!;
+        return list;
     }
 
-    /// <summary>
-    /// Gets the latest TV show items with smart Season/Series container selection.
-    /// </summary>
-    /// <remarks>
-    /// <para>
-    /// This method implements intelligent container selection for TV shows in the "Latest" section.
-    /// Instead of always showing individual episodes, it analyzes recent additions and may return
-    /// a Season or Series container when multiple related episodes were recently added.
-    /// </para>
-    /// <para>
-    /// The selection logic is:
-    /// <list type="bullet">
-    ///     <item>If recent episodes span multiple seasons → return the Series</item>
-    ///     <item>If multiple recent episodes are from one season AND the series has multiple seasons → return the Season</item>
-    ///     <item>If multiple recent episodes are from one season AND the series has only one season → return the Series</item>
-    ///     <item>Otherwise → return the most recent Episode</item>
-    /// </list>
-    /// </para>
-    /// </remarks>
-    /// <param name="context">The database context.</param>
-    /// <param name="baseQuery">The base query with filters already applied.</param>
-    /// <param name="filter">The query filter options.</param>
-    /// <param name="limit">Maximum number of items to return.</param>
-    /// <returns>A list of BaseItemDto representing the latest TV content.</returns>
-    private IReadOnlyList<BaseItemDto> GetLatestTvShowItems(JellyfinDbContext context, IQueryable<BaseItemEntity> baseQuery, InternalItemsQuery filter, int? limit)
+    private bool IsTypeInQuery(BaseItemKind type, InternalItemsQuery query)
     {
-        // Episodes added within this window are considered "recently added together"
-        const double RecentAdditionWindowHours = 24.0;
-
-        // Step 1: Find the top N series with recently added content, ordered by most recent addition
-        var topSeriesWithDates = baseQuery
-            .Where(e => e.SeriesName != null)
-            .GroupBy(e => e.SeriesName)
-            .Select(g => new { SeriesName = g.Key!, MaxDate = g.Max(e => e.DateCreated) })
-            .OrderByDescending(g => g.MaxDate);
-
-        if (limit.HasValue)
+        if (query.ExcludeItemTypes.Contains(type))
         {
-            topSeriesWithDates = topSeriesWithDates.Take(limit.Value).OrderByDescending(g => g.MaxDate);
+            return false;
         }
 
-        var topSeriesNames = topSeriesWithDates.Select(g => g.SeriesName).AsEnumerable();
-
-        // Compute a global date cutoff: the oldest series' max date minus the window.
-        // Episodes before this cutoff cannot be in any series' "recent additions" window,
-        // so we can safely exclude them to avoid loading ancient episodes.
-        var globalCutoff = topSeriesWithDates.Any()
-            ? topSeriesWithDates.Min(g => g.MaxDate)?.AddHours(-RecentAdditionWindowHours)
-            : null;
+        return query.IncludeItemTypes.Length == 0 || query.IncludeItemTypes.Contains(type);
+    }
 
-        // Fetch only the columns needed for analysis (lightweight projection).
-        var episodeQuery = baseQuery.Where(e => e.SeriesName != null && topSeriesNames.Contains(e.SeriesName));
-        if (globalCutoff is not null)
+    private bool EnableGroupByPresentationUniqueKey(InternalItemsQuery query)
+    {
+        if (!query.GroupByPresentationUniqueKey)
         {
-            episodeQuery = episodeQuery.Where(e => e.DateCreated >= globalCutoff);
+            return false;
         }
 
-        var allEpisodes = episodeQuery
-            .OrderByDescending(e => e.DateCreated)
-            .ThenByDescending(e => e.Id)
-            .Select(e => new { e.Id, e.SeriesName, e.DateCreated, e.SeasonId, e.SeriesId })
-            .AsEnumerable();
-
-        // Collect all season/series IDs we'll need to look up for count information
-        var allSeasonIds = new HashSet<Guid>();
-        var allSeriesIds = new HashSet<Guid>();
-
-        // Analysis data for each series: recent episode count, season IDs, and the most recent episode ID
-        var analysisData = new List<(
-            int RecentEpisodeCount,
-            List<Guid> SeasonIds,
-            Guid? FirstRecentSeriesId,
-            DateTime MaxDate,
-            Guid MostRecentEpisodeId)>();
-
-        // Step 3: Analyze each series to identify recent additions within the time window
-        foreach (var group in allEpisodes.GroupBy(e => e.SeriesName))
+        if (query.GroupBySeriesPresentationUniqueKey)
         {
-            var episodes = group.ToList();
-            var mostRecentDate = episodes[0].DateCreated ?? DateTime.MinValue;
-            var recentCutoff = mostRecentDate.AddHours(-RecentAdditionWindowHours);
-
-            // Find episodes added within the recent window
-            var recentEpisodeCount = 0;
-            var seasonIdSet = new HashSet<Guid>();
-            Guid? firstRecentSeriesId = null;
-
-            foreach (var ep in episodes)
-            {
-                if (ep.DateCreated >= recentCutoff)
-                {
-                    recentEpisodeCount++;
-                    if (ep.SeasonId.HasValue)
-                    {
-                        seasonIdSet.Add(ep.SeasonId.Value);
-                    }
-
-                    firstRecentSeriesId ??= ep.SeriesId;
-                }
-            }
-
-            var seasonIds = seasonIdSet.ToList();
-            analysisData.Add((recentEpisodeCount, seasonIds, firstRecentSeriesId, mostRecentDate, episodes[0].Id));
-
-            // Track all unique season/series IDs for batch lookups
-            foreach (var sid in seasonIds)
-            {
-                allSeasonIds.Add(sid);
-            }
-
-            if (firstRecentSeriesId.HasValue)
-            {
-                allSeriesIds.Add(firstRecentSeriesId.Value);
-            }
+            return false;
         }
 
-        // Step 4: Batch fetch counts - episodes per season and seasons per series
-        // These counts help determine whether to show Season or Series as the container
-        var episodeType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];
-        var seasonType = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Season];
-        var seasonEpisodeCounts = allSeasonIds.Count > 0
-            ? context.BaseItems
-                .AsNoTracking()
-                .Where(e => e.SeasonId.HasValue && allSeasonIds.Contains(e.SeasonId.Value) && e.Type == episodeType)
-                .GroupBy(e => e.SeasonId!.Value)
-                .Select(g => new { SeasonId = g.Key, Count = g.Count() })
-                .ToDictionary(x => x.SeasonId, x => x.Count)
-            : [];
-
-        var seriesSeasonCounts = allSeriesIds.Count > 0
-            ? context.BaseItems
-                .AsNoTracking()
-                .Where(e => e.SeriesId.HasValue && allSeriesIds.Contains(e.SeriesId.Value) && e.Type == seasonType)
-                .GroupBy(e => e.SeriesId!.Value)
-                .Select(g => new { SeriesId = g.Key, Count = g.Count() })
-                .ToDictionary(x => x.SeriesId, x => x.Count)
-            : [];
-
-        // Step 5: Apply the container selection logic for each series.
-        // For each series, decide which entity best represents the recent additions:
-        //   - 1 episode added → show the Episode itself
-        //   - Multiple episodes in 1 season (multi-season series) → show the Season
-        //   - Multiple episodes in 1 season (single-season series) → show the Series
-        //   - Episodes across multiple seasons → show the Series
-        var entitiesToFetch = new HashSet<Guid>();
-        var seriesResults = new List<(Guid? SeasonId, Guid? SeriesId, DateTime MaxDate, Guid MostRecentEpisodeId)>(analysisData.Count);
-
-        foreach (var (recentEpisodeCount, seasonIds, firstRecentSeriesId, maxDate, mostRecentEpisodeId) in analysisData)
+        if (!string.IsNullOrWhiteSpace(query.PresentationUniqueKey))
         {
-            Guid? seasonId = null;
-            Guid? seriesId = null;
-
-            if (seasonIds.Count == 1)
-            {
-                // All recent episodes are from a single season
-                var sid = seasonIds[0];
-                var totalEpisodes = seasonEpisodeCounts.GetValueOrDefault(sid, 0);
-                var totalSeasonsInSeries = firstRecentSeriesId.HasValue
-                    ? seriesSeasonCounts.GetValueOrDefault(firstRecentSeriesId.Value, 1)
-                    : 1;
-
-                // Check if multiple episodes were added, or if all episodes in the season were added
-                var hasMultipleOrAllEpisodes = recentEpisodeCount > 1 || recentEpisodeCount == totalEpisodes;
-
-                if (totalSeasonsInSeries > 1 && hasMultipleOrAllEpisodes)
-                {
-                    // Multi-season series with bulk additions: show the Season
-                    seasonId = sid;
-                    entitiesToFetch.Add(sid);
-                }
-                else if (hasMultipleOrAllEpisodes && firstRecentSeriesId.HasValue)
-                {
-                    // Single-season series with bulk additions: show the Series
-                    seriesId = firstRecentSeriesId;
-                    entitiesToFetch.Add(firstRecentSeriesId.Value);
-                }
-
-                // Otherwise: single episode, will fall through to show the Episode
-            }
-            else if (seasonIds.Count > 1 && firstRecentSeriesId.HasValue)
-            {
-                // Recent episodes span multiple seasons: show the Series
-                seriesId = firstRecentSeriesId;
-                entitiesToFetch.Add(seriesId!.Value);
-            }
-
-            if (seasonId is null && seriesId is null)
-            {
-                entitiesToFetch.Add(mostRecentEpisodeId);
-            }
-
-            seriesResults.Add((seasonId, seriesId, maxDate, mostRecentEpisodeId));
+            return false;
         }
 
-        // Step 6: Fetch the Season/Series entities we decided to return
-        var entities = entitiesToFetch.Count > 0
-            ? ApplyNavigations(
-                    context.BaseItems.AsNoTracking().Where(e => entitiesToFetch.Contains(e.Id)),
-                    filter)
-                .AsSingleQuery()
-                .ToDictionary(e => e.Id)
-            : [];
-
-        // Step 7: Build final results, preferring Season > Series > Episode.
-        // All needed entities are already fetched in step 6 with navigation properties.
-        var results = new List<(BaseItemEntity Entity, DateTime MaxDate)>(seriesResults.Count);
-        foreach (var (seasonId, seriesId, maxDate, mostRecentEpisodeId) in seriesResults)
+        if (query.User is null)
         {
-            if (seasonId.HasValue && entities.TryGetValue(seasonId.Value, out var seasonEntity))
-            {
-                results.Add((seasonEntity, maxDate));
-                continue;
-            }
-
-            if (seriesId.HasValue && entities.TryGetValue(seriesId.Value, out var seriesEntity))
-            {
-                results.Add((seriesEntity, maxDate));
-                continue;
-            }
-
-            if (entities.TryGetValue(mostRecentEpisodeId, out var episodeEntity))
-            {
-                results.Add((episodeEntity, maxDate));
-            }
+            return false;
         }
 
-        var finalResults = results
-            .OrderByDescending(r => r.MaxDate)
-            .ThenByDescending(r => r.Entity.Id);
-
-        if (limit.HasValue)
+        if (query.IncludeItemTypes.Length == 0)
         {
-            finalResults = finalResults
-            .Take(limit.Value)
-            .OrderByDescending(r => r.MaxDate)
-            .ThenByDescending(r => r.Entity.Id);
+            return true;
         }
 
-        return finalResults
-            .Select(r => DeserializeBaseItem(r.Entity, filter.SkipDeserialization))
-            .Where(dto => dto is not null)
-            .ToArray()!;
+        return query.IncludeItemTypes.Contains(BaseItemKind.Episode)
+            || query.IncludeItemTypes.Contains(BaseItemKind.Video)
+            || query.IncludeItemTypes.Contains(BaseItemKind.Movie)
+            || query.IncludeItemTypes.Contains(BaseItemKind.MusicVideo)
+            || query.IncludeItemTypes.Contains(BaseItemKind.Series)
+            || query.IncludeItemTypes.Contains(BaseItemKind.Season);
     }
 
-    /// <inheritdoc />
-    public IReadOnlyList<string> GetNextUpSeriesKeys(InternalItemsQuery filter, DateTime dateCutoff)
+    private static BaseItemImageInfo Map(Guid baseItemId, ItemImageInfo e)
     {
-        ArgumentNullException.ThrowIfNull(filter);
-        ArgumentNullException.ThrowIfNull(filter.User);
-
-        using var context = _dbProvider.CreateDbContext();
-
-        var query = context.BaseItems
-            .AsNoTracking()
-            .Where(i => filter.TopParentIds.Contains(i.TopParentId!.Value))
-            .Where(i => i.Type == _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode])
-            .Join(
-                context.UserData.AsNoTracking().Where(e => e.ItemId != EF.Constant(PlaceholderId)),
-                i => new { UserId = filter.User.Id, ItemId = i.Id },
-                u => new { u.UserId, u.ItemId },
-                (entity, data) => new { Item = entity, UserData = data })
-            .GroupBy(g => g.Item.SeriesPresentationUniqueKey)
-            .Select(g => new { g.Key, LastPlayedDate = g.Max(u => u.UserData.LastPlayedDate) })
-            .Where(g => g.Key != null && g.LastPlayedDate != null && g.LastPlayedDate >= dateCutoff)
-            .OrderByDescending(g => g.LastPlayedDate)
-            .Select(g => g.Key!);
-
-        if (filter.Limit.HasValue)
-        {
-            query = query.Take(filter.Limit.Value);
-        }
-
-        return query.ToArray();
+        return BaseItemMapper.MapImageToEntity(baseItemId, e);
     }
 
-    /// <inheritdoc />
-    public IReadOnlyDictionary<string, NextUpEpisodeBatchResult> GetNextUpEpisodesBatch(
-        InternalItemsQuery filter,
-        IReadOnlyList<string> seriesKeys,
-        bool includeSpecials,
-        bool includeWatchedForRewatching)
+    private static ItemImageInfo Map(BaseItemImageInfo e, IServerApplicationHost? appHost)
     {
-        ArgumentNullException.ThrowIfNull(filter);
-        ArgumentNullException.ThrowIfNull(filter.User);
-
-        if (seriesKeys.Count == 0)
-        {
-            return new Dictionary<string, NextUpEpisodeBatchResult>();
-        }
-
-        PrepareFilterQuery(filter);
-        using var context = _dbProvider.CreateDbContext();
-
-        var userId = filter.User.Id;
-        var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];
-
-        // Get the last watched episode ID per series (highest season/episode that is played)
-        var lastWatchedBase = context.BaseItems
-            .AsNoTracking()
-            .Where(e => e.Type == episodeTypeName)
-            .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
-            .Where(e => e.ParentIndexNumber != 0)
-            .Where(e => e.UserData!.Any(ud => ud.UserId == userId && ud.Played));
-        lastWatchedBase = ApplyAccessFiltering(context, lastWatchedBase, filter);
-        var lastWatchedInfo = lastWatchedBase
-            .GroupBy(e => e.SeriesPresentationUniqueKey)
-            .Select(g => new
-            {
-                SeriesKey = g.Key!,
-                LastWatchedId = g.OrderByDescending(e => e.ParentIndexNumber)
-                                 .ThenByDescending(e => e.IndexNumber)
-                                 .Select(e => e.Id)
-                                 .FirstOrDefault()
-            })
-            .ToDictionary(x => x.SeriesKey, x => x.LastWatchedId);
-
-        Dictionary<string, Guid> lastWatchedByDateInfo = new();
-        if (includeWatchedForRewatching)
-        {
-            var lastWatchedByDateBase = context.BaseItems
-                .AsNoTracking()
-                .Where(e => e.Type == episodeTypeName)
-                .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
-                .Where(e => e.ParentIndexNumber != 0)
-                .Where(e => e.UserData!.Any(ud => ud.UserId == userId && ud.Played));
-            lastWatchedByDateBase = ApplyAccessFiltering(context, lastWatchedByDateBase, filter);
-            lastWatchedByDateInfo = lastWatchedByDateBase
-                .SelectMany(e => e.UserData!.Where(ud => ud.UserId == userId && ud.Played)
-                    .Select(ud => new { Episode = e, ud.LastPlayedDate }))
-                .GroupBy(x => x.Episode.SeriesPresentationUniqueKey)
-                .Select(g => new
-                {
-                    SeriesKey = g.Key!,
-                    LastWatchedId = g.OrderByDescending(x => x.LastPlayedDate)
-                                     .Select(x => x.Episode.Id)
-                                     .FirstOrDefault()
-                })
-                .ToDictionary(x => x.SeriesKey, x => x.LastWatchedId);
-        }
-
-        // Two-query pattern: The queries above use GroupBy(...).Select(g => g.OrderBy(...).First())
-        // to pick the single best episode ID per series. EF Core ignores .Include() calls when the
-        // query shape changes through GroupBy/Select projections (see dotnet/efcore#13450),
-        // so navigation properties (Images, Providers, etc.) cannot be loaded in that query.
-        // We first identify which episode IDs we need, then fetch full entities with nav props
-        // only for those few items (~1 per series).
-        var allLastWatchedIds = lastWatchedInfo.Values
-            .Concat(lastWatchedByDateInfo.Values)
-            .Where(id => id != Guid.Empty)
-            .Distinct()
-            .ToList();
-        var lastWatchedEpisodes = new Dictionary<Guid, BaseItemEntity>();
-        if (allLastWatchedIds.Count > 0)
-        {
-            var lwQuery = context.BaseItems.AsNoTracking().Where(e => allLastWatchedIds.Contains(e.Id));
-            lwQuery = ApplyNavigations(lwQuery, filter);
-            lastWatchedEpisodes = lwQuery.ToDictionary(e => e.Id);
-        }
-
-        Dictionary<string, List<BaseItemEntity>> specialsBySeriesKey = new();
-        if (includeSpecials)
-        {
-            var specialsQuery = context.BaseItems
-                .AsNoTracking()
-                .Where(e => e.Type == episodeTypeName)
-                .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
-                .Where(e => e.ParentIndexNumber == 0)
-                .Where(e => !e.IsVirtualItem);
-            specialsQuery = ApplyAccessFiltering(context, specialsQuery, filter);
-            specialsQuery = ApplyNavigations(specialsQuery, filter).AsSingleQuery();
-
-            foreach (var special in specialsQuery)
-            {
-                var key = special.SeriesPresentationUniqueKey!;
-                if (!specialsBySeriesKey.TryGetValue(key, out var list))
-                {
-                    list = new List<BaseItemEntity>();
-                    specialsBySeriesKey[key] = list;
-                }
-
-                list.Add(special);
-            }
-        }
-
-        // Build position lookup from already-loaded last watched data
-        var positionLookup = new Dictionary<string, (int Season, int Episode)>();
-        foreach (var kvp in lastWatchedInfo)
-        {
-            if (kvp.Value != Guid.Empty
-                && lastWatchedEpisodes.TryGetValue(kvp.Value, out var lw)
-                && lw.ParentIndexNumber.HasValue
-                && lw.IndexNumber.HasValue)
-            {
-                positionLookup[kvp.Key] = (lw.ParentIndexNumber.Value, lw.IndexNumber.Value);
-            }
-        }
-
-        // Single query: fetch all unplayed non-virtual non-special episodes for all series.
-        // Uses NOT EXISTS (via !Any) for the played check, which is more efficient than GroupJoin.
-        // Only unplayed episodes are loaded (typically ~10% of total), keeping memory usage low.
-        var allUnplayedBase = context.BaseItems
-            .AsNoTracking()
-            .Where(e => e.Type == episodeTypeName)
-            .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
-            .Where(e => e.ParentIndexNumber != 0)
-            .Where(e => !e.IsVirtualItem)
-            .Where(e => !e.UserData!.Any(ud => ud.UserId == userId && ud.Played));
-        allUnplayedBase = ApplyAccessFiltering(context, allUnplayedBase, filter);
-        var allUnplayedCandidates = allUnplayedBase
-            .Select(e => new
-            {
-                e.Id,
-                e.SeriesPresentationUniqueKey,
-                e.ParentIndexNumber,
-                EpisodeNumber = e.IndexNumber
-            })
-            .ToList();
-
-        // In-memory: find the next unplayed episode per series, respecting last-watched position
-        var nextEpisodeIds = new HashSet<Guid>();
-        var seriesNextIdMap = new Dictionary<string, Guid>();
-
-        foreach (var seriesKey in seriesKeys)
-        {
-            var candidates = allUnplayedCandidates
-                .Where(c => c.SeriesPresentationUniqueKey == seriesKey);
-
-            if (positionLookup.TryGetValue(seriesKey, out var pos))
-            {
-                candidates = candidates.Where(c =>
-                    c.ParentIndexNumber > pos.Season
-                    || (c.ParentIndexNumber == pos.Season && c.EpisodeNumber > pos.Episode));
-            }
-
-            var nextCandidate = candidates
-                .OrderBy(c => c.ParentIndexNumber)
-                .ThenBy(c => c.EpisodeNumber)
-                .FirstOrDefault();
-
-            if (nextCandidate is not null && nextCandidate.Id != Guid.Empty)
-            {
-                nextEpisodeIds.Add(nextCandidate.Id);
-                seriesNextIdMap[seriesKey] = nextCandidate.Id;
-            }
-        }
-
-        // Find next played episode per series for rewatching mode
-        var seriesNextPlayedIdMap = new Dictionary<string, Guid>();
-        if (includeWatchedForRewatching)
-        {
-            var allPlayedBase = context.BaseItems
-                .AsNoTracking()
-                .Where(e => e.Type == episodeTypeName)
-                .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
-                .Where(e => e.ParentIndexNumber != 0)
-                .Where(e => !e.IsVirtualItem)
-                .Where(e => e.UserData!.Any(ud => ud.UserId == userId && ud.Played));
-            allPlayedBase = ApplyAccessFiltering(context, allPlayedBase, filter);
-            var allPlayedCandidates = allPlayedBase
-                .Select(e => new
-                {
-                    e.Id,
-                    e.SeriesPresentationUniqueKey,
-                    e.ParentIndexNumber,
-                    EpisodeNumber = e.IndexNumber
-                })
-                .ToList();
-
-            foreach (var seriesKey in seriesKeys)
-            {
-                if (!lastWatchedByDateInfo.TryGetValue(seriesKey, out var lastByDateId))
-                {
-                    continue;
-                }
-
-                var lastByDateEntity = lastWatchedEpisodes.GetValueOrDefault(lastByDateId);
-                if (lastByDateEntity is null)
-                {
-                    continue;
-                }
-
-                var playedCandidates = allPlayedCandidates
-                    .Where(c => c.SeriesPresentationUniqueKey == seriesKey);
-
-                if (lastByDateEntity.ParentIndexNumber.HasValue && lastByDateEntity.IndexNumber.HasValue)
-                {
-                    var lastSeason = lastByDateEntity.ParentIndexNumber.Value;
-                    var lastEp = lastByDateEntity.IndexNumber.Value;
-                    playedCandidates = playedCandidates.Where(c =>
-                        c.ParentIndexNumber > lastSeason
-                        || (c.ParentIndexNumber == lastSeason && c.EpisodeNumber > lastEp));
-                }
-
-                var nextPlayedCandidate = playedCandidates
-                    .OrderBy(c => c.ParentIndexNumber)
-                    .ThenBy(c => c.EpisodeNumber)
-                    .FirstOrDefault();
-
-                if (nextPlayedCandidate is not null && nextPlayedCandidate.Id != Guid.Empty)
-                {
-                    nextEpisodeIds.Add(nextPlayedCandidate.Id);
-                    seriesNextPlayedIdMap[seriesKey] = nextPlayedCandidate.Id;
-                }
-            }
-        }
-
-        // Batch fetch all next episode entities with navigation properties
-        var nextEpisodes = new Dictionary<Guid, BaseItemEntity>();
-        if (nextEpisodeIds.Count > 0)
-        {
-            var nextQuery = context.BaseItems.AsNoTracking().Where(e => nextEpisodeIds.Contains(e.Id));
-            nextQuery = ApplyNavigations(nextQuery, filter).AsSingleQuery();
-            nextEpisodes = nextQuery.ToDictionary(e => e.Id);
-        }
-
-        var result = new Dictionary<string, NextUpEpisodeBatchResult>();
-        foreach (var seriesKey in seriesKeys)
-        {
-            var batchResult = new NextUpEpisodeBatchResult();
-
-            if (lastWatchedInfo.TryGetValue(seriesKey, out var lwId) && lwId != Guid.Empty)
-            {
-                if (lastWatchedEpisodes.TryGetValue(lwId, out var entity))
-                {
-                    batchResult.LastWatched = DeserializeBaseItem(entity, filter.SkipDeserialization);
-                }
-            }
-
-            if (seriesNextIdMap.TryGetValue(seriesKey, out var nextId) && nextEpisodes.TryGetValue(nextId, out var nextEntity))
-            {
-                batchResult.NextUp = DeserializeBaseItem(nextEntity, filter.SkipDeserialization);
-            }
-
-            if (includeSpecials && specialsBySeriesKey.TryGetValue(seriesKey, out var specials))
-            {
-                batchResult.Specials = specials.Select(s => DeserializeBaseItem(s, filter.SkipDeserialization)!).ToList();
-            }
-            else
-            {
-                batchResult.Specials = Array.Empty<BaseItemDto>();
-            }
-
-            if (includeWatchedForRewatching)
-            {
-                if (lastWatchedByDateInfo.TryGetValue(seriesKey, out var lastByDateId) &&
-                    lastWatchedEpisodes.TryGetValue(lastByDateId, out var lastByDateEntity))
-                {
-                    batchResult.LastWatchedForRewatching = DeserializeBaseItem(lastByDateEntity, filter.SkipDeserialization);
-                }
-
-                if (seriesNextPlayedIdMap.TryGetValue(seriesKey, out var nextPlayedId) &&
-                    nextEpisodes.TryGetValue(nextPlayedId, out var nextPlayedEntity))
-                {
-                    batchResult.NextPlayedForRewatching = DeserializeBaseItem(nextPlayedEntity, filter.SkipDeserialization);
-                }
-            }
-
-            result[seriesKey] = batchResult;
-        }
-
-        return result;
+        return BaseItemMapper.MapImageFromEntity(e, appHost);
     }
 
-    private IQueryable<BaseItemEntity> ApplyGroupingFilter(JellyfinDbContext context, IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
+    private string? GetPathToSave(string path)
     {
-        // This whole block is needed to filter duplicate entries on request
-        // for the time being it cannot be used because it would destroy the ordering
-        // this results in "duplicate" responses for queries that try to lookup individual series or multiple versions but
-        // for that case the invoker has to run a DistinctBy(e => e.PresentationUniqueKey) on their own
-
-        var enableGroupByPresentationUniqueKey = EnableGroupByPresentationUniqueKey(filter);
-        if (enableGroupByPresentationUniqueKey && filter.GroupBySeriesPresentationUniqueKey)
-        {
-            var tempQuery = dbQuery.GroupBy(e => new { e.PresentationUniqueKey, e.SeriesPresentationUniqueKey }).Select(e => e.OrderBy(x => x.Id).FirstOrDefault()).Select(e => e!.Id);
-            dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));
-        }
-        else if (enableGroupByPresentationUniqueKey)
-        {
-            var tempQuery = dbQuery.GroupBy(e => e.PresentationUniqueKey).Select(e => e.OrderBy(x => x.Id).FirstOrDefault()).Select(e => e!.Id);
-            dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));
-        }
-        else if (filter.GroupBySeriesPresentationUniqueKey)
-        {
-            var tempQuery = dbQuery.GroupBy(e => e.SeriesPresentationUniqueKey).Select(e => e.OrderBy(x => x.Id).FirstOrDefault()).Select(e => e!.Id);
-            dbQuery = context.BaseItems.Where(e => tempQuery.Contains(e.Id));
-        }
-        else
-        {
-            dbQuery = dbQuery.Distinct();
-        }
-
-        if (filter.CollapseBoxSetItems == true)
+        if (path is null)
         {
-            dbQuery = ApplyBoxSetCollapsing(context, dbQuery, filter.CollapseBoxSetItemTypes);
-
-            // Apply name-range filters after collapse so BoxSets are filtered by their own name,
-            // not by their children's names.
-            dbQuery = ApplyNameFilters(dbQuery, filter);
+            return null;
         }
 
-        dbQuery = ApplyOrder(dbQuery, filter, context);
-
-        return dbQuery;
+        return _appHost.ReverseVirtualPath(path);
     }
 
-    private IQueryable<BaseItemEntity> ApplyBoxSetCollapsing(
-        JellyfinDbContext context,
-        IQueryable<BaseItemEntity> dbQuery,
-        BaseItemKind[] collapsibleTypes)
+    /// <inheritdoc />
+    public BaseItemDto? DeserializeBaseItem(BaseItemEntity entity, bool skipDeserialization = false)
     {
-        var boxSetTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.BoxSet];
-
-        var currentIds = dbQuery.Select(e => e.Id);
-
-        if (collapsibleTypes.Length == 0)
+        ArgumentNullException.ThrowIfNull(entity, nameof(entity));
+        if (_serverConfigurationManager?.Configuration is null)
         {
-            // Collapse all item types into box sets
-            return ApplyBoxSetCollapsingAll(context, currentIds, boxSetTypeName);
+            throw new InvalidOperationException("Server Configuration manager or configuration is null");
         }
 
-        // Only collapse specific item types, keep others untouched
-        var collapsibleTypeNames = collapsibleTypes.Select(t => _itemTypeLookup.BaseItemKindNames[t]).ToList();
-
-        // Items whose type is NOT collapsible (always kept in results)
-        var nonCollapsibleIds = currentIds
-            .Where(id => !context.BaseItems.Any(bi => bi.Id == id && collapsibleTypeNames.Contains(bi.Type)));
-
-        // Collapsible items that are NOT in any box set (kept in results)
-        var collapsibleNotInBoxSet = currentIds
-            .Where(id =>
-                context.BaseItems.Any(bi => bi.Id == id && collapsibleTypeNames.Contains(bi.Type))
-                && !context.BaseItems.Any(bs => bs.Id == id && bs.Type == boxSetTypeName)
-                && !context.LinkedChildren.Any(lc =>
-                    lc.ChildId == id
-                    && lc.ChildType == DbLinkedChildType.Manual
-                    && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName)));
-
-        // Box set IDs containing at least one accessible collapsible child item
-        var boxSetIds = context.LinkedChildren
-            .Where(lc =>
-                lc.ChildType == DbLinkedChildType.Manual
-                && currentIds.Contains(lc.ChildId)
-                && context.BaseItems.Any(bi => bi.Id == lc.ChildId && collapsibleTypeNames.Contains(bi.Type))
-                && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName))
-            .Select(lc => lc.ParentId)
-            .Distinct();
-
-        var collapsedIds = nonCollapsibleIds.Union(collapsibleNotInBoxSet).Union(boxSetIds);
-        return context.BaseItems.Where(e => collapsedIds.Contains(e.Id));
-    }
-
-    private static IQueryable<BaseItemEntity> ApplyBoxSetCollapsingAll(
-        JellyfinDbContext context,
-        IQueryable<Guid> currentIds,
-        string boxSetTypeName)
-    {
-        // Items that are NOT box sets and NOT in any box set
-        var notInBoxSet = currentIds
-            .Where(id =>
-                !context.BaseItems.Any(bs => bs.Id == id && bs.Type == boxSetTypeName)
-                && !context.LinkedChildren.Any(lc =>
-                    lc.ChildId == id
-                    && lc.ChildType == DbLinkedChildType.Manual
-                    && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName)));
-
-        // Box set IDs containing at least one accessible child item
-        var boxSetIds = context.LinkedChildren
-            .Where(lc =>
-                lc.ChildType == DbLinkedChildType.Manual
-                && currentIds.Contains(lc.ChildId)
-                && context.BaseItems.Any(bs => bs.Id == lc.ParentId && bs.Type == boxSetTypeName))
-            .Select(lc => lc.ParentId)
-            .Distinct();
-
-        var collapsedIds = notInBoxSet.Union(boxSetIds);
-        return context.BaseItems.Where(e => collapsedIds.Contains(e.Id));
-    }
-
-    private static IQueryable<BaseItemEntity> ApplyNameFilters(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
-    {
-        if (!string.IsNullOrWhiteSpace(filter.NameStartsWith))
-        {
-            var nameStartsWithLower = filter.NameStartsWith.ToLowerInvariant();
-            dbQuery = dbQuery.Where(e => e.SortName!.ToLower().StartsWith(nameStartsWithLower));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.NameStartsWithOrGreater))
-        {
-            var startsOrGreaterLower = filter.NameStartsWithOrGreater.ToLowerInvariant();
-            dbQuery = dbQuery.Where(e => e.SortName!.ToLower().CompareTo(startsOrGreaterLower) >= 0);
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.NameLessThan))
-        {
-            var lessThanLower = filter.NameLessThan.ToLowerInvariant();
-            dbQuery = dbQuery.Where(e => e.SortName!.ToLower().CompareTo(lessThanLower) < 0);
-        }
-
-        return dbQuery;
-    }
-
-    private static IQueryable<BaseItemEntity> ApplyNavigations(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
-    {
-        if (filter.TrailerTypes.Length > 0 || filter.IncludeItemTypes.Contains(BaseItemKind.Trailer))
-        {
-            dbQuery = dbQuery.Include(e => e.TrailerTypes);
-        }
-
-        if (filter.DtoOptions.ContainsField(ItemFields.ProviderIds))
-        {
-            dbQuery = dbQuery.Include(e => e.Provider);
-        }
-
-        if (filter.DtoOptions.ContainsField(ItemFields.Settings))
-        {
-            dbQuery = dbQuery.Include(e => e.LockedFields);
-        }
-
-        if (filter.DtoOptions.EnableUserData)
-        {
-            dbQuery = dbQuery.Include(e => e.UserData);
-        }
-
-        if (filter.DtoOptions.EnableImages)
-        {
-            dbQuery = dbQuery.Include(e => e.Images);
-        }
-
-        // Include LinkedChildEntities for container types and videos that use them
-        // (BoxSet, Playlist, CollectionFolder for manual linking; Video, Movie for alternate versions).
-        // When IncludeItemTypes is empty (any type may be returned), always include them to ensure
-        // LinkedChildren are loaded before items are saved back, preventing accidental deletion.
-        var linkedChildTypes = new[]
-        {
-            BaseItemKind.BoxSet,
-            BaseItemKind.Playlist,
-            BaseItemKind.CollectionFolder,
-            BaseItemKind.Video,
-            BaseItemKind.Movie
-        };
-        if (filter.IncludeItemTypes.Length == 0 || filter.IncludeItemTypes.Any(linkedChildTypes.Contains))
-        {
-            dbQuery = dbQuery.Include(e => e.LinkedChildEntities);
-        }
-
-        if (filter.IncludeExtras)
-        {
-            dbQuery = dbQuery.Include(e => e.Extras);
-        }
-
-        return dbQuery;
-    }
-
-    private IQueryable<BaseItemEntity> ApplyQueryPaging(IQueryable<BaseItemEntity> dbQuery, InternalItemsQuery filter)
-    {
-        if (filter.Limit.HasValue || filter.StartIndex.HasValue)
-        {
-            var offset = filter.StartIndex ?? 0;
-
-            if (offset > 0)
-            {
-                dbQuery = dbQuery.Skip(offset);
-            }
-
-            if (filter.Limit.HasValue)
-            {
-                dbQuery = dbQuery.Take(filter.Limit.Value);
-            }
-        }
-
-        return dbQuery;
-    }
-
-    private IQueryable<BaseItemEntity> ApplyQueryFilter(IQueryable<BaseItemEntity> dbQuery, JellyfinDbContext context, InternalItemsQuery filter)
-    {
-        dbQuery = TranslateQuery(dbQuery, context, filter);
-        dbQuery = ApplyGroupingFilter(context, dbQuery, filter);
-        dbQuery = ApplyQueryPaging(dbQuery, filter);
-        dbQuery = ApplyNavigations(dbQuery, filter);
-        return dbQuery;
-    }
-
-    private IQueryable<BaseItemEntity> PrepareItemQuery(JellyfinDbContext context, InternalItemsQuery filter)
-    {
-        IQueryable<BaseItemEntity> dbQuery = context.BaseItems.AsNoTracking();
-        dbQuery = dbQuery.AsSingleQuery();
-
-        return dbQuery;
-    }
-
-    /// <inheritdoc/>
-    public int GetCount(InternalItemsQuery filter)
-    {
-        ArgumentNullException.ThrowIfNull(filter);
-        // Hack for right now since we currently don't support filtering out these duplicates within a query
-        PrepareFilterQuery(filter);
-
-        using var context = _dbProvider.CreateDbContext();
-        var dbQuery = TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);
-
-        return dbQuery.Count();
-    }
-
-    /// <inheritdoc />
-    public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter)
-    {
-        ArgumentNullException.ThrowIfNull(filter);
-        PrepareFilterQuery(filter);
-
-        using var context = _dbProvider.CreateDbContext();
-        var baseQuery = PrepareItemQuery(context, filter);
-        baseQuery = TranslateQuery(baseQuery, context, filter);
-
-        // Get matching item IDs as a subquery (not materialized)
-        var matchingItemIds = baseQuery.Select(e => e.Id);
-
-        // Query distinct years directly from the database
-        var years = baseQuery
-            .Where(e => e.ProductionYear != null && e.ProductionYear > 0)
-            .Select(e => e.ProductionYear!.Value)
-            .Distinct()
-            .OrderBy(y => y)
-            .ToArray();
-
-        // Query distinct official ratings directly from the database
-        var officialRatings = baseQuery
-            .Where(e => e.OfficialRating != null && e.OfficialRating != string.Empty)
-            .Select(e => e.OfficialRating!)
-            .Distinct()
-            .OrderBy(r => r)
-            .ToArray();
-
-        // Tags via ItemValuesMap JOIN - uses subquery for matching items and dedupe based on CleanValue, but return the original Value for display
-        var tags = context.ItemValuesMap
-            .Where(ivm => ivm.ItemValue.Type == ItemValueType.Tags)
-            .Where(ivm => matchingItemIds.Contains(ivm.ItemId))
-            .Select(ivm => ivm.ItemValue)
-            .GroupBy(iv => iv.CleanValue)
-            .Select(g => g.OrderBy(iv => iv.Value).First().Value)
-            .OrderBy(t => t)
-            .ToArray();
-
-        // Genres via ItemValuesMap JOIN - uses subquery for matching items and dedupe based on CleanValue, but return the original Value for display
-        var genres = context.ItemValuesMap
-            .Where(ivm => ivm.ItemValue.Type == ItemValueType.Genre)
-            .Where(ivm => matchingItemIds.Contains(ivm.ItemId))
-            .Select(ivm => ivm.ItemValue)
-            .GroupBy(iv => iv.CleanValue)
-            .Select(g => g.OrderBy(iv => iv.Value).First().Value)
-            .OrderBy(g => g)
-            .ToArray();
-
-        return new QueryFiltersLegacy
-        {
-            Years = years,
-            OfficialRatings = officialRatings,
-            Tags = tags,
-            Genres = genres
-        };
-    }
-
-    /// <inheritdoc />
-    public ItemCounts GetItemCounts(InternalItemsQuery filter)
-    {
-        ArgumentNullException.ThrowIfNull(filter);
-        // Hack for right now since we currently don't support filtering out these duplicates within a query
-        PrepareFilterQuery(filter);
-
-        using var context = _dbProvider.CreateDbContext();
-        var dbQuery = TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);
-
-        var counts = dbQuery
-            .GroupBy(x => x.Type)
-            .Select(x => new { x.Key, Count = x.Count() })
-            .ToArray();
-
-        var lookup = _itemTypeLookup.BaseItemKindNames;
-        var result = new ItemCounts
-        {
-            ItemCount = counts.Sum(c => c.Count)
-        };
-        foreach (var count in counts)
-        {
-            if (string.Equals(count.Key, lookup[BaseItemKind.MusicAlbum], StringComparison.Ordinal))
-            {
-                result.AlbumCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicArtist], StringComparison.Ordinal))
-            {
-                result.ArtistCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Episode], StringComparison.Ordinal))
-            {
-                result.EpisodeCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Movie], StringComparison.Ordinal))
-            {
-                result.MovieCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicVideo], StringComparison.Ordinal))
-            {
-                result.MusicVideoCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.LiveTvProgram], StringComparison.Ordinal))
-            {
-                result.ProgramCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Series], StringComparison.Ordinal))
-            {
-                result.SeriesCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Audio], StringComparison.Ordinal))
-            {
-                result.SongCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Trailer], StringComparison.Ordinal))
-            {
-                result.TrailerCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.BoxSet], StringComparison.Ordinal))
-            {
-                result.BoxSetCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Book], StringComparison.Ordinal))
-            {
-                result.BookCount = count.Count;
-            }
-        }
-
-        return result;
-    }
-
-    /// <inheritdoc />
-    public ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, InternalItemsQuery accessFilter)
-    {
-        using var context = _dbProvider.CreateDbContext();
-
-        // Look up the item's name/cleanname
-        var item = context.BaseItems.AsNoTracking()
-            .Where(e => e.Id == id)
-            .Select(e => new { e.Name, e.CleanName })
-            .FirstOrDefault();
-
-        if (item is null)
-        {
-            return new ItemCounts();
-        }
-
-        // Build the base query starting from the mapping table (flipped join order)
-        IQueryable<BaseItemEntity> baseQuery;
-        switch (kind)
-        {
-            case BaseItemKind.Person:
-                baseQuery = context.PeopleBaseItemMap
-                    .AsNoTracking()
-                    .Where(m => m.People.Name == item.Name)
-                    .Select(m => m.Item);
-                break;
-            case BaseItemKind.MusicArtist:
-                baseQuery = context.ItemValuesMap
-                    .AsNoTracking()
-                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
-                        && (ivm.ItemValue.Type == ItemValueType.Artist || ivm.ItemValue.Type == ItemValueType.AlbumArtist))
-                    .Select(ivm => ivm.Item);
-                break;
-            case BaseItemKind.Genre:
-            case BaseItemKind.MusicGenre:
-                baseQuery = context.ItemValuesMap
-                    .AsNoTracking()
-                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
-                        && ivm.ItemValue.Type == ItemValueType.Genre)
-                    .Select(ivm => ivm.Item);
-                break;
-            case BaseItemKind.Studio:
-                baseQuery = context.ItemValuesMap
-                    .AsNoTracking()
-                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
-                        && ivm.ItemValue.Type == ItemValueType.Studios)
-                    .Select(ivm => ivm.Item);
-                break;
-            case BaseItemKind.Year:
-                if (int.TryParse(item.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var year))
-                {
-                    baseQuery = context.BaseItems
-                        .AsNoTracking()
-                        .Where(e => e.ProductionYear == year);
-                }
-                else
-                {
-                    return new ItemCounts();
-                }
-
-                break;
-            default:
-                return new ItemCounts();
-        }
-
-        // Apply type filter
-        var typeNames = relatedItemKinds.Select(k => _itemTypeLookup.BaseItemKindNames[k]).ToArray();
-        baseQuery = baseQuery.Where(e => typeNames.Contains(e.Type));
-
-        // Apply access filtering (parental ratings, blocked/allowed tags, library access)
-        baseQuery = ApplyAccessFiltering(context, baseQuery, accessFilter);
-
-        // Group by type and count
-        var counts = baseQuery
-            .GroupBy(x => x.Type)
-            .Select(x => new { x.Key, Count = x.Count() })
-            .ToArray();
-
-        var lookup = _itemTypeLookup.BaseItemKindNames;
-        var result = new ItemCounts();
-        var totalCount = 0;
-
-        foreach (var count in counts)
-        {
-            totalCount += count.Count;
-
-            if (string.Equals(count.Key, lookup[BaseItemKind.MusicAlbum], StringComparison.Ordinal))
-            {
-                result.AlbumCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicArtist], StringComparison.Ordinal))
-            {
-                result.ArtistCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Episode], StringComparison.Ordinal))
-            {
-                result.EpisodeCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Movie], StringComparison.Ordinal))
-            {
-                result.MovieCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicVideo], StringComparison.Ordinal))
-            {
-                result.MusicVideoCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.LiveTvProgram], StringComparison.Ordinal))
-            {
-                result.ProgramCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Series], StringComparison.Ordinal))
-            {
-                result.SeriesCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Audio], StringComparison.Ordinal))
-            {
-                result.SongCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Trailer], StringComparison.Ordinal))
-            {
-                result.TrailerCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.BoxSet], StringComparison.Ordinal))
-            {
-                result.BoxSetCount = count.Count;
-            }
-            else if (string.Equals(count.Key, lookup[BaseItemKind.Book], StringComparison.Ordinal))
-            {
-                result.BookCount = count.Count;
-            }
-        }
-
-        result.ItemCount = totalCount;
-
-        return result;
-    }
-
-#pragma warning disable CA1307 // Specify StringComparison for clarity
-    /// <summary>
-    /// Gets the type.
-    /// </summary>
-    /// <param name="typeName">Name of the type.</param>
-    /// <returns>Type.</returns>
-    /// <exception cref="ArgumentNullException"><c>typeName</c> is null.</exception>
-    private static Type? GetType(string typeName)
-    {
-        ArgumentException.ThrowIfNullOrEmpty(typeName);
-
-        // TODO: this isn't great. Refactor later to be both globally handled by a dedicated service not just an static variable and be loaded eagerly.
-        // currently this is done so that plugins may introduce their own type of baseitems as we dont know when we are first called, before or after plugins are loaded
-        return _typeMap.GetOrAdd(typeName, k => AppDomain.CurrentDomain.GetAssemblies()
-            .Select(a => a.GetType(k))
-            .FirstOrDefault(t => t is not null));
-    }
-
-    /// <inheritdoc  />
-    public void SaveItems(IReadOnlyList<BaseItemDto> items, CancellationToken cancellationToken)
-    {
-        UpdateOrInsertItems(items, cancellationToken);
-    }
-
-    /// <inheritdoc />
-    public async Task SaveImagesAsync(BaseItem item, CancellationToken cancellationToken = default)
-    {
-        ArgumentNullException.ThrowIfNull(item);
-
-        var images = item.ImageInfos.Select(e => Map(item.Id, e)).ToArray();
-
-        var context = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
-        await using (context.ConfigureAwait(false))
-        {
-            if (!await context.BaseItems
-                .AnyAsync(bi => bi.Id == item.Id, cancellationToken)
-                .ConfigureAwait(false))
-            {
-                _logger.LogWarning("Unable to save ImageInfo for non existing BaseItem");
-                return;
-            }
-
-            await context.BaseItemImageInfos
-                .Where(e => e.ItemId == item.Id)
-                .ExecuteDeleteAsync(cancellationToken)
-                .ConfigureAwait(false);
-
-            await context.BaseItemImageInfos
-                .AddRangeAsync(images, cancellationToken)
-                .ConfigureAwait(false);
-
-            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
-        }
-    }
-
-    /// <inheritdoc cref="IItemRepository"/>
-    public void UpdateOrInsertItems(IReadOnlyList<BaseItemDto> items, CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(items);
-        cancellationToken.ThrowIfCancellationRequested();
-
-        var tuples = new List<(BaseItemDto Item, List<Guid>? AncestorIds, BaseItemDto TopParent, IEnumerable<string> UserDataKey, List<string> InheritedTags)>();
-        foreach (var item in items.GroupBy(e => e.Id).Select(e => e.Last()).Where(e => e.Id != PlaceholderId))
-        {
-            var ancestorIds = item.SupportsAncestors ?
-                item.GetAncestorIds().Distinct().ToList() :
-                null;
-
-            var topParent = item.GetTopParent();
-
-            var userdataKey = item.GetUserDataKeys();
-            var inheritedTags = item.GetInheritedTags();
-
-            tuples.Add((item, ancestorIds, topParent, userdataKey, inheritedTags));
-        }
-
-        using var context = _dbProvider.CreateDbContext();
-        using var transaction = context.Database.BeginTransaction();
-
-        var ids = tuples.Select(f => f.Item.Id).ToArray();
-        var existingItems = context.BaseItems.Where(e => ids.Contains(e.Id)).Select(f => f.Id).ToArray();
-
-        foreach (var item in tuples)
-        {
-            var entity = Map(item.Item);
-            // TODO: refactor this "inconsistency"
-            entity.TopParentId = item.TopParent?.Id;
-
-            if (!existingItems.Any(e => e == entity.Id))
-            {
-                context.BaseItems.Add(entity);
-            }
-            else
-            {
-                context.BaseItemProviders.Where(e => e.ItemId == entity.Id).ExecuteDelete();
-                context.BaseItemImageInfos.Where(e => e.ItemId == entity.Id).ExecuteDelete();
-                context.BaseItemMetadataFields.Where(e => e.ItemId == entity.Id).ExecuteDelete();
-
-                if (entity.Images is { Count: > 0 })
-                {
-                    context.BaseItemImageInfos.AddRange(entity.Images);
-                }
-
-                if (entity.LockedFields is { Count: > 0 })
-                {
-                    context.BaseItemMetadataFields.AddRange(entity.LockedFields);
-                }
-
-                context.BaseItems.Attach(entity).State = EntityState.Modified;
-            }
-        }
-
-        var itemValueMaps = tuples
-            .Select(e => (e.Item, Values: GetItemValuesToSave(e.Item, e.InheritedTags)))
-            .ToArray();
-        var allListedItemValues = itemValueMaps
-            .SelectMany(f => f.Values)
-            .Distinct()
-            .ToArray();
-        var existingValues = context.ItemValues
-            .Select(e => new
-            {
-                item = e,
-                Key = e.Type + "+" + e.Value
-            })
-            .Where(f => allListedItemValues.Select(e => $"{(int)e.MagicNumber}+{e.Value}").Contains(f.Key))
-            .Select(e => e.item)
-            .ToArray();
-        var missingItemValues = allListedItemValues.Except(existingValues.Select(f => (MagicNumber: f.Type, f.Value))).Select(f => new ItemValue()
-        {
-            CleanValue = f.Value.GetCleanValue(),
-            ItemValueId = Guid.NewGuid(),
-            Type = f.MagicNumber,
-            Value = f.Value
-        }).ToArray();
-        context.ItemValues.AddRange(missingItemValues);
-
-        var itemValuesStore = existingValues.Concat(missingItemValues).ToArray();
-        var valueMap = itemValueMaps
-            .Select(f => (f.Item, Values: f.Values.Select(e => itemValuesStore.First(g => g.Value == e.Value && g.Type == e.MagicNumber)).DistinctBy(e => e.ItemValueId).ToArray()))
-            .ToArray();
-
-        var mappedValues = context.ItemValuesMap.Where(e => ids.Contains(e.ItemId)).ToList();
-
-        foreach (var item in valueMap)
-        {
-            var itemMappedValues = mappedValues.Where(e => e.ItemId == item.Item.Id).ToList();
-            foreach (var itemValue in item.Values)
-            {
-                var existingItem = itemMappedValues.FirstOrDefault(f => f.ItemValueId == itemValue.ItemValueId);
-                if (existingItem is null)
-                {
-                    context.ItemValuesMap.Add(new ItemValueMap()
-                    {
-                        Item = null!,
-                        ItemId = item.Item.Id,
-                        ItemValue = null!,
-                        ItemValueId = itemValue.ItemValueId
-                    });
-                }
-                else
-                {
-                    // map exists, remove from list so its been handled.
-                    itemMappedValues.Remove(existingItem);
-                }
-            }
-
-            // all still listed values are not in the new list so remove them.
-            context.ItemValuesMap.RemoveRange(itemMappedValues);
-        }
-
-        var itemsWithAncestors = tuples
-            .Where(t => t.Item.SupportsAncestors && t.AncestorIds != null)
-            .Select(t => t.Item.Id)
-            .ToList();
-
-        var allExistingAncestorIds = itemsWithAncestors.Count > 0
-            ? context.AncestorIds
-                .Where(e => itemsWithAncestors.Contains(e.ItemId))
-                .ToList()
-                .GroupBy(e => e.ItemId)
-                .ToDictionary(g => g.Key, g => g.ToList())
-            : new Dictionary<Guid, List<AncestorId>>();
-
-        var allRequestedAncestorIds = tuples
-            .Where(t => t.Item.SupportsAncestors && t.AncestorIds != null)
-            .SelectMany(t => t.AncestorIds!)
-            .Distinct()
-            .ToList();
-
-        var validAncestorIdsSet = allRequestedAncestorIds.Count > 0
-            ? context.BaseItems
-                .Where(e => allRequestedAncestorIds.Contains(e.Id))
-                .Select(f => f.Id)
-                .ToHashSet()
-            : new HashSet<Guid>();
-
-        foreach (var item in tuples)
-        {
-            if (item.Item.SupportsAncestors && item.AncestorIds != null)
-            {
-                var existingAncestorIds = allExistingAncestorIds.GetValueOrDefault(item.Item.Id) ?? new List<AncestorId>();
-                var validAncestorIds = item.AncestorIds.Where(id => validAncestorIdsSet.Contains(id)).ToArray();
-                foreach (var ancestorId in validAncestorIds)
-                {
-                    var existingAncestorId = existingAncestorIds.FirstOrDefault(e => e.ParentItemId == ancestorId);
-                    if (existingAncestorId is null)
-                    {
-                        context.AncestorIds.Add(new AncestorId()
-                        {
-                            ParentItemId = ancestorId,
-                            ItemId = item.Item.Id,
-                            Item = null!,
-                            ParentItem = null!
-                        });
-                    }
-                    else
-                    {
-                        existingAncestorIds.Remove(existingAncestorId);
-                    }
-                }
-
-                context.AncestorIds.RemoveRange(existingAncestorIds);
-            }
-        }
-
-        // This is necessary because LocalAlternateVersions resolution queries the database by path,
-        // and newly imported alternate version items need to exist before we can link them
-        context.SaveChanges();
-
-        var folderIds = tuples
-            .Where(t => t.Item is Folder)
-            .Select(t => t.Item.Id)
-            .ToList();
-
-        var videoIds = tuples
-            .Where(t => t.Item is Video)
-            .Select(t => t.Item.Id)
-            .ToList();
-
-        var allLinkedChildrenByParent = new Dictionary<Guid, List<LinkedChildEntity>>();
-        if (folderIds.Count > 0 || videoIds.Count > 0)
-        {
-            var allParentIds = folderIds.Concat(videoIds).Distinct().ToList();
-            var allLinkedChildren = context.LinkedChildren
-                .Where(e => allParentIds.Contains(e.ParentId))
-                .ToList();
-
-            allLinkedChildrenByParent = allLinkedChildren
-                .GroupBy(e => e.ParentId)
-                .ToDictionary(g => g.Key, g => g.ToList());
-        }
-
-        foreach (var item in tuples)
-        {
-            if (item.Item is Folder folder)
-            {
-                var existingLinkedChildren = allLinkedChildrenByParent.GetValueOrDefault(item.Item.Id)?.ToList() ?? new List<LinkedChildEntity>();
-                if (folder.LinkedChildren.Length > 0)
-                {
-#pragma warning disable CS0618 // Type or member is obsolete - legacy path resolution for old data
-                    var pathsToResolve = folder.LinkedChildren
-                        .Where(lc => (!lc.ItemId.HasValue || lc.ItemId.Value.IsEmpty()) && !string.IsNullOrEmpty(lc.Path))
-                        .Select(lc => lc.Path)
-                        .Distinct()
-                        .ToList();
-
-                    var pathToIdMap = pathsToResolve.Count > 0
-                        ? context.BaseItems
-                            .Where(e => e.Path != null && pathsToResolve.Contains(e.Path))
-                            .Select(e => new { e.Path, e.Id })
-                            .GroupBy(e => e.Path!)
-                            .ToDictionary(g => g.Key, g => g.First().Id)
-                        : [];
-
-                    var resolvedChildren = new List<(LinkedChild Child, Guid ChildId)>();
-                    foreach (var linkedChild in folder.LinkedChildren)
-                    {
-                        var childItemId = linkedChild.ItemId;
-                        if (!childItemId.HasValue || childItemId.Value.IsEmpty())
-                        {
-                            if (!string.IsNullOrEmpty(linkedChild.Path) && pathToIdMap.TryGetValue(linkedChild.Path, out var resolvedId))
-                            {
-                                childItemId = resolvedId;
-                            }
-                        }
-#pragma warning restore CS0618
-
-                        if (childItemId.HasValue && !childItemId.Value.IsEmpty())
-                        {
-                            resolvedChildren.Add((linkedChild, childItemId.Value));
-                        }
-                    }
-
-                    // Deduplicate by ChildId, keeping the last occurrence (for playlist ordering)
-                    resolvedChildren = resolvedChildren
-                        .GroupBy(c => c.ChildId)
-                        .Select(g => g.Last())
-                        .ToList();
-
-                    var childIdsToCheck = resolvedChildren.Select(c => c.ChildId).ToList();
-                    var existingChildIds = childIdsToCheck.Count > 0
-                        ? context.BaseItems
-                            .Where(e => childIdsToCheck.Contains(e.Id))
-                            .Select(e => e.Id)
-                            .ToHashSet()
-                        : [];
-
-                    var isPlaylist = folder is Playlist;
-                    var sortOrder = 0;
-                    foreach (var (linkedChild, childId) in resolvedChildren)
-                    {
-                        if (!existingChildIds.Contains(childId))
-                        {
-                            _logger.LogWarning(
-                                "Skipping LinkedChild for parent {ParentName} ({ParentId}): child item {ChildId} does not exist in database",
-                                item.Item.Name,
-                                item.Item.Id,
-                                childId);
-                            continue;
-                        }
-
-                        var existingLink = existingLinkedChildren.FirstOrDefault(e => e.ChildId == childId);
-                        if (existingLink is null)
-                        {
-                            context.LinkedChildren.Add(new LinkedChildEntity()
-                            {
-                                ParentId = item.Item.Id,
-                                ChildId = childId,
-                                ChildType = (DbLinkedChildType)linkedChild.Type,
-                                SortOrder = isPlaylist ? sortOrder : null
-                            });
-                        }
-                        else
-                        {
-                            existingLink.SortOrder = isPlaylist ? sortOrder : null;
-                            existingLink.ChildType = (DbLinkedChildType)linkedChild.Type;
-                            existingLinkedChildren.Remove(existingLink);
-                        }
-
-                        sortOrder++;
-                    }
-                }
-
-                if (existingLinkedChildren.Count > 0)
-                {
-                    context.LinkedChildren.RemoveRange(existingLinkedChildren);
-                }
-            }
-
-            // Handle Video alternate versions
-            if (item.Item is Video video)
-            {
-                // Use batch-fetched data and filter for alternate version types (2 = LocalAlternateVersion, 3 = LinkedAlternateVersion)
-                var existingLinkedChildren = (allLinkedChildrenByParent.GetValueOrDefault(video.Id) ?? new List<LinkedChildEntity>())
-                    .Where(e => (int)e.ChildType == 2 || (int)e.ChildType == 3)
-                    .ToList();
-
-                var newLinkedChildren = new List<(Guid ChildId, LinkedChildType Type)>();
-
-                // Process LocalAlternateVersions (path-based alternate versions)
-                if (video.LocalAlternateVersions.Length > 0)
-                {
-                    var pathsToResolve = video.LocalAlternateVersions.Where(p => !string.IsNullOrEmpty(p)).ToList();
-                    if (pathsToResolve.Count > 0)
-                    {
-                        var pathToIdMap = context.BaseItems
-                            .Where(e => e.Path != null && pathsToResolve.Contains(e.Path))
-                            .Select(e => new { e.Path, e.Id })
-                            .GroupBy(e => e.Path!)
-                            .ToDictionary(g => g.Key, g => g.First().Id);
-
-                        foreach (var path in pathsToResolve)
-                        {
-                            if (pathToIdMap.TryGetValue(path, out var childId))
-                            {
-                                newLinkedChildren.Add((childId, LinkedChildType.LocalAlternateVersion));
-                            }
-                        }
-                    }
-                }
-
-                // Process LinkedAlternateVersions (ID-based alternate versions)
-                if (video.LinkedAlternateVersions.Length > 0)
-                {
-                    foreach (var linkedChild in video.LinkedAlternateVersions)
-                    {
-                        if (linkedChild.ItemId.HasValue && !linkedChild.ItemId.Value.IsEmpty())
-                        {
-                            newLinkedChildren.Add((linkedChild.ItemId.Value, LinkedChildType.LinkedAlternateVersion));
-                        }
-                    }
-                }
-
-                // Deduplicate by ChildId, keeping the last occurrence
-                newLinkedChildren = newLinkedChildren
-                    .GroupBy(c => c.ChildId)
-                    .Select(g => g.Last())
-                    .ToList();
-
-                // Validate that all child items exist
-                var childIdsToCheck = newLinkedChildren.Select(c => c.ChildId).ToList();
-                var existingChildIds = childIdsToCheck.Count > 0
-                    ? context.BaseItems
-                        .Where(e => childIdsToCheck.Contains(e.Id))
-                        .Select(e => e.Id)
-                        .ToHashSet()
-                    : [];
-
-                // Add or update LinkedChildren entries
-                int sortOrder = 0;
-                foreach (var (childId, childType) in newLinkedChildren)
-                {
-                    if (!existingChildIds.Contains(childId))
-                    {
-                        _logger.LogWarning(
-                            "Skipping alternate version for video {VideoName} ({VideoId}): child item {ChildId} does not exist in database",
-                            video.Name,
-                            video.Id,
-                            childId);
-                        continue;
-                    }
-
-                    var existingLink = existingLinkedChildren.FirstOrDefault(e => e.ChildId == childId);
-                    if (existingLink is null)
-                    {
-                        context.LinkedChildren.Add(new LinkedChildEntity
-                        {
-                            ParentId = video.Id,
-                            ChildId = childId,
-                            ChildType = (DbLinkedChildType)childType,
-                            SortOrder = sortOrder
-                        });
-                    }
-                    else
-                    {
-                        existingLink.ChildType = (DbLinkedChildType)childType;
-                        existingLink.SortOrder = sortOrder;
-                        existingLinkedChildren.Remove(existingLink);
-                    }
-
-                    sortOrder++;
-                }
-
-                // Remove orphaned alternate version links and their items
-                if (existingLinkedChildren.Count > 0)
-                {
-                    // Get the child IDs of LocalAlternateVersions that are being removed
-                    // These items should be deleted as they are owned by this video
-                    var orphanedLocalVersionIds = existingLinkedChildren
-                        .Where(e => e.ChildType == DbLinkedChildType.LocalAlternateVersion)
-                        .Select(e => e.ChildId)
-                        .ToList();
-
-                    context.LinkedChildren.RemoveRange(existingLinkedChildren);
-
-                    // Delete the orphaned LocalAlternateVersion items themselves
-                    if (orphanedLocalVersionIds.Count > 0)
-                    {
-                        var orphanedItems = context.BaseItems
-                            .Where(e => orphanedLocalVersionIds.Contains(e.Id) && e.OwnerId == video.Id)
-                            .ToList();
-
-                        if (orphanedItems.Count > 0)
-                        {
-                            _logger.LogInformation(
-                                "Deleting {Count} orphaned LocalAlternateVersion items for video {VideoName} ({VideoId})",
-                                orphanedItems.Count,
-                                video.Name,
-                                video.Id);
-                            context.BaseItems.RemoveRange(orphanedItems);
-                        }
-                    }
-                }
-            }
-        }
-
-        // Phase 2 commit: Save LinkedChildren changes
-        context.SaveChanges();
-        transaction.Commit();
-    }
-
-    /// <summary>
-    /// Reattaches user data entries that were incorrectly associated with a different item.
-    /// </summary>
-    /// <param name="item">The item DTO to reattach user data for.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>A task representing the asynchronous operation.</returns>
-    public async Task ReattachUserDataAsync(BaseItemDto item, CancellationToken cancellationToken)
-    {
-        ArgumentNullException.ThrowIfNull(item);
-        cancellationToken.ThrowIfCancellationRequested();
-
-        var dbContext = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
-
-        await using (dbContext.ConfigureAwait(false))
-        {
-            var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken).ConfigureAwait(false);
-            await using (transaction.ConfigureAwait(false))
-            {
-                var userKeys = item.GetUserDataKeys().ToArray();
-                var retentionDate = (DateTime?)null;
-
-                await dbContext.UserData
-                    .Where(e => e.ItemId == PlaceholderId)
-                    .Where(e => userKeys.Contains(e.CustomDataKey))
-                    .ExecuteUpdateAsync(
-                        e => e
-                            .SetProperty(f => f.ItemId, item.Id)
-                            .SetProperty(f => f.RetentionDate, retentionDate),
-                        cancellationToken).ConfigureAwait(false);
-
-                // Rehydrate the cached userdata
-                item.UserData = await dbContext.UserData
-                    .AsNoTracking()
-                    .Where(e => e.ItemId == item.Id)
-                    .ToArrayAsync(cancellationToken)
-                    .ConfigureAwait(false);
-
-                await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
-            }
-        }
-    }
-
-    /// <inheritdoc  />
-    public BaseItemDto? RetrieveItem(Guid id)
-    {
-        if (id.IsEmpty())
-        {
-            throw new ArgumentException("Guid can't be empty", nameof(id));
-        }
-
-        using var context = _dbProvider.CreateDbContext();
-        var dbQuery = PrepareItemQuery(context, new()
-        {
-            DtoOptions = new()
-            {
-                EnableImages = true
-            }
-        });
-        dbQuery = dbQuery.Include(e => e.TrailerTypes)
-            .Include(e => e.Provider)
-            .Include(e => e.LockedFields)
-            .Include(e => e.UserData)
-            .Include(e => e.Images)
-            .Include(e => e.LinkedChildEntities)
-            .AsSingleQuery();
-
-        var item = dbQuery.FirstOrDefault(e => e.Id == id);
-        if (item is null)
-        {
-            return null;
-        }
-
-        return DeserializeBaseItem(item);
-    }
-
-    /// <summary>
-    /// Maps a Entity to the DTO.
-    /// </summary>
-    /// <param name="entity">The entity.</param>
-    /// <param name="dto">The dto base instance.</param>
-    /// <param name="appHost">The Application server Host.</param>
-    /// <param name="logger">The applogger.</param>
-    /// <returns>The dto to map.</returns>
-    public static BaseItemDto Map(BaseItemEntity entity, BaseItemDto dto, IServerApplicationHost? appHost, ILogger logger)
-    {
-        dto.Id = entity.Id;
-        dto.ParentId = entity.ParentId.GetValueOrDefault();
-        dto.Path = appHost?.ExpandVirtualPath(entity.Path) ?? entity.Path;
-        dto.EndDate = entity.EndDate;
-        dto.CommunityRating = entity.CommunityRating;
-        dto.CustomRating = entity.CustomRating;
-        dto.IndexNumber = entity.IndexNumber;
-        dto.IsLocked = entity.IsLocked;
-        dto.Name = entity.Name;
-        dto.OfficialRating = entity.OfficialRating;
-        dto.Overview = entity.Overview;
-        dto.ParentIndexNumber = entity.ParentIndexNumber;
-        dto.PremiereDate = entity.PremiereDate;
-        dto.ProductionYear = entity.ProductionYear;
-        dto.SortName = entity.SortName;
-        dto.ForcedSortName = entity.ForcedSortName;
-        dto.RunTimeTicks = entity.RunTimeTicks;
-        dto.PreferredMetadataLanguage = entity.PreferredMetadataLanguage;
-        dto.PreferredMetadataCountryCode = entity.PreferredMetadataCountryCode;
-        dto.IsInMixedFolder = entity.IsInMixedFolder;
-        dto.InheritedParentalRatingValue = entity.InheritedParentalRatingValue;
-        dto.InheritedParentalRatingSubValue = entity.InheritedParentalRatingSubValue;
-        dto.CriticRating = entity.CriticRating;
-        dto.PresentationUniqueKey = entity.PresentationUniqueKey;
-        dto.OriginalTitle = entity.OriginalTitle;
-        dto.Album = entity.Album;
-        dto.LUFS = entity.LUFS;
-        dto.NormalizationGain = entity.NormalizationGain;
-        dto.IsVirtualItem = entity.IsVirtualItem;
-        dto.ExternalSeriesId = entity.ExternalSeriesId;
-        dto.Tagline = entity.Tagline;
-        dto.TotalBitrate = entity.TotalBitrate;
-        dto.ExternalId = entity.ExternalId;
-        dto.Size = entity.Size;
-        dto.Genres = string.IsNullOrWhiteSpace(entity.Genres) ? [] : entity.Genres.Split('|');
-        dto.DateCreated = entity.DateCreated ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
-        dto.DateModified = entity.DateModified ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
-        dto.ChannelId = entity.ChannelId ?? Guid.Empty;
-        dto.DateLastRefreshed = entity.DateLastRefreshed ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
-        dto.DateLastSaved = entity.DateLastSaved ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
-        dto.OwnerId = entity.OwnerId ?? Guid.Empty;
-        dto.Width = entity.Width.GetValueOrDefault();
-        dto.Height = entity.Height.GetValueOrDefault();
-        dto.UserData = entity.UserData;
-
-        if (entity.Provider is not null)
-        {
-            dto.ProviderIds = entity.Provider.ToDictionary(e => e.ProviderId, e => e.ProviderValue);
-        }
-
-        if (entity.ExtraType is not null)
-        {
-            dto.ExtraType = (ExtraType)entity.ExtraType;
-        }
-
-        if (entity.LockedFields is not null)
-        {
-            dto.LockedFields = entity.LockedFields?.Select(e => (MetadataField)e.Id).ToArray() ?? [];
-        }
-
-        if (entity.Audio is not null)
-        {
-            dto.Audio = (ProgramAudio)entity.Audio;
-        }
-
-        dto.ProductionLocations = entity.ProductionLocations?.Split('|', StringSplitOptions.RemoveEmptyEntries) ?? [];
-        dto.Studios = entity.Studios?.Split('|') ?? [];
-        dto.Tags = string.IsNullOrWhiteSpace(entity.Tags) ? [] : entity.Tags.Split('|');
-
-        if (dto is IHasProgramAttributes hasProgramAttributes)
-        {
-            hasProgramAttributes.IsMovie = entity.IsMovie;
-            hasProgramAttributes.IsSeries = entity.IsSeries;
-            hasProgramAttributes.EpisodeTitle = entity.EpisodeTitle;
-            hasProgramAttributes.IsRepeat = entity.IsRepeat;
-        }
-
-        if (dto is LiveTvChannel liveTvChannel)
-        {
-            liveTvChannel.ServiceName = entity.ExternalServiceId;
-        }
-
-        if (dto is Trailer trailer)
-        {
-            trailer.TrailerTypes = entity.TrailerTypes?.Select(e => (TrailerType)e.Id).ToArray() ?? [];
-        }
-
-        if (dto is Video video)
-        {
-            video.PrimaryVersionId = entity.PrimaryVersionId;
-        }
-
-        if (dto is IHasSeries hasSeriesName)
-        {
-            hasSeriesName.SeriesName = entity.SeriesName;
-            hasSeriesName.SeriesId = entity.SeriesId.GetValueOrDefault();
-            hasSeriesName.SeriesPresentationUniqueKey = entity.SeriesPresentationUniqueKey;
-        }
-
-        if (dto is Episode episode)
-        {
-            episode.SeasonName = entity.SeasonName;
-            episode.SeasonId = entity.SeasonId.GetValueOrDefault();
-        }
-
-        if (dto is IHasArtist hasArtists)
-        {
-            hasArtists.Artists = entity.Artists?.Split('|', StringSplitOptions.RemoveEmptyEntries) ?? [];
-        }
-
-        if (dto is IHasAlbumArtist hasAlbumArtists)
-        {
-            hasAlbumArtists.AlbumArtists = entity.AlbumArtists?.Split('|', StringSplitOptions.RemoveEmptyEntries) ?? [];
-        }
-
-        if (dto is LiveTvProgram program)
-        {
-            program.ShowId = entity.ShowId;
-        }
-
-        if (entity.Images is not null)
-        {
-            dto.ImageInfos = entity.Images.Select(e => Map(e, appHost)).ToArray();
-        }
-
-        // dto.Type = entity.Type;
-        // dto.Data = entity.Data;
-        // dto.MediaType = Enum.TryParse<MediaType>(entity.MediaType);
-        if (dto is IHasStartDate hasStartDate)
-        {
-            hasStartDate.StartDate = entity.StartDate.GetValueOrDefault();
-        }
-
-        // Fields that are present in the DB but are never actually used
-        // dto.UnratedType = entity.UnratedType;
-        // dto.TopParentId = entity.TopParentId;
-        // dto.CleanName = entity.CleanName;
-        // dto.UserDataKey = entity.UserDataKey;
-
-        if (dto is Folder folder)
-        {
-            folder.DateLastMediaAdded = entity.DateLastMediaAdded ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc);
-            if (entity.LinkedChildEntities is not null && entity.LinkedChildEntities.Count > 0)
-            {
-                folder.LinkedChildren = entity.LinkedChildEntities
-                    .OrderBy(e => e.SortOrder)
-                    .Select(e => new LinkedChild
-                    {
-                        ItemId = e.ChildId,
-                        Type = (LinkedChildType)e.ChildType
-                    })
-                    .ToArray();
-            }
-        }
-
-        return dto;
-    }
-
-    /// <summary>
-    /// Maps a Entity to the DTO.
-    /// </summary>
-    /// <param name="dto">The entity.</param>
-    /// <returns>The dto to map.</returns>
-    public BaseItemEntity Map(BaseItemDto dto)
-    {
-        var dtoType = dto.GetType();
-        var entity = new BaseItemEntity()
-        {
-            Type = dtoType.ToString(),
-            Id = dto.Id
-        };
-
-        if (TypeRequiresDeserialization(dtoType))
-        {
-            entity.Data = JsonSerializer.Serialize(dto, dtoType, JsonDefaults.Options);
-        }
-
-        entity.ParentId = !dto.ParentId.IsEmpty() ? dto.ParentId : null;
-        entity.Path = GetPathToSave(dto.Path);
-        entity.EndDate = dto.EndDate;
-        entity.CommunityRating = dto.CommunityRating;
-        entity.CustomRating = dto.CustomRating;
-        entity.IndexNumber = dto.IndexNumber;
-        entity.IsLocked = dto.IsLocked;
-        entity.Name = dto.Name;
-        entity.CleanName = dto.Name.GetCleanValue();
-        entity.OfficialRating = dto.OfficialRating;
-        entity.Overview = dto.Overview;
-        entity.ParentIndexNumber = dto.ParentIndexNumber;
-        entity.PremiereDate = dto.PremiereDate;
-        entity.ProductionYear = dto.ProductionYear;
-        entity.SortName = dto.SortName;
-        entity.ForcedSortName = dto.ForcedSortName;
-        entity.RunTimeTicks = dto.RunTimeTicks;
-        entity.PreferredMetadataLanguage = dto.PreferredMetadataLanguage;
-        entity.PreferredMetadataCountryCode = dto.PreferredMetadataCountryCode;
-        entity.IsInMixedFolder = dto.IsInMixedFolder;
-        entity.InheritedParentalRatingValue = dto.InheritedParentalRatingValue;
-        entity.InheritedParentalRatingSubValue = dto.InheritedParentalRatingSubValue;
-        entity.CriticRating = dto.CriticRating;
-        entity.PresentationUniqueKey = dto.PresentationUniqueKey;
-        entity.OriginalTitle = dto.OriginalTitle;
-        entity.Album = dto.Album;
-        entity.LUFS = dto.LUFS;
-        entity.NormalizationGain = dto.NormalizationGain;
-        entity.IsVirtualItem = dto.IsVirtualItem;
-        entity.ExternalSeriesId = dto.ExternalSeriesId;
-        entity.Tagline = dto.Tagline;
-        entity.TotalBitrate = dto.TotalBitrate;
-        entity.ExternalId = dto.ExternalId;
-        entity.Size = dto.Size;
-        entity.Genres = string.Join('|', dto.Genres);
-        entity.DateCreated = dto.DateCreated == DateTime.MinValue ? null : dto.DateCreated;
-        entity.DateModified = dto.DateModified == DateTime.MinValue ? null : dto.DateModified;
-        entity.ChannelId = dto.ChannelId;
-        entity.DateLastRefreshed = dto.DateLastRefreshed == DateTime.MinValue ? null : dto.DateLastRefreshed;
-        entity.DateLastSaved = dto.DateLastSaved == DateTime.MinValue ? null : dto.DateLastSaved;
-        entity.OwnerId = dto.OwnerId == Guid.Empty ? null : dto.OwnerId;
-        entity.Width = dto.Width;
-        entity.Height = dto.Height;
-        entity.Provider = dto.ProviderIds.Select(e => new BaseItemProvider()
-        {
-            Item = entity,
-            ProviderId = e.Key,
-            ProviderValue = e.Value
-        }).ToList();
-
-        if (dto.Audio.HasValue)
-        {
-            entity.Audio = (ProgramAudioEntity)dto.Audio;
-        }
-
-        if (dto.ExtraType.HasValue)
-        {
-            entity.ExtraType = (BaseItemExtraType)dto.ExtraType;
-        }
-
-        entity.ProductionLocations = dto.ProductionLocations is not null ? string.Join('|', dto.ProductionLocations.Where(p => !string.IsNullOrWhiteSpace(p))) : null;
-        entity.Studios = dto.Studios is not null ? string.Join('|', dto.Studios) : null;
-        entity.Tags = dto.Tags is not null ? string.Join('|', dto.Tags) : null;
-        entity.LockedFields = dto.LockedFields is not null ? dto.LockedFields
-            .Select(e => new BaseItemMetadataField()
-            {
-                Id = (int)e,
-                Item = entity,
-                ItemId = entity.Id
-            })
-            .ToArray() : null;
-
-        if (dto is IHasProgramAttributes hasProgramAttributes)
-        {
-            entity.IsMovie = hasProgramAttributes.IsMovie;
-            entity.IsSeries = hasProgramAttributes.IsSeries;
-            entity.EpisodeTitle = hasProgramAttributes.EpisodeTitle;
-            entity.IsRepeat = hasProgramAttributes.IsRepeat;
-        }
-
-        if (dto is LiveTvChannel liveTvChannel)
-        {
-            entity.ExternalServiceId = liveTvChannel.ServiceName;
-        }
-
-        if (dto is Video video)
-        {
-            entity.PrimaryVersionId = video.PrimaryVersionId;
-        }
-
-        if (dto is IHasSeries hasSeriesName)
-        {
-            entity.SeriesName = hasSeriesName.SeriesName;
-            entity.SeriesId = hasSeriesName.SeriesId;
-            entity.SeriesPresentationUniqueKey = hasSeriesName.SeriesPresentationUniqueKey;
-        }
-
-        if (dto is Episode episode)
-        {
-            entity.SeasonName = episode.SeasonName;
-            entity.SeasonId = episode.SeasonId;
-        }
-
-        if (dto is IHasArtist hasArtists)
-        {
-            entity.Artists = hasArtists.Artists is not null ? string.Join('|', hasArtists.Artists) : null;
-        }
-
-        if (dto is IHasAlbumArtist hasAlbumArtists)
-        {
-            entity.AlbumArtists = hasAlbumArtists.AlbumArtists is not null ? string.Join('|', hasAlbumArtists.AlbumArtists) : null;
-        }
-
-        if (dto is LiveTvProgram program)
-        {
-            entity.ShowId = program.ShowId;
-        }
-
-        if (dto.ImageInfos is not null)
-        {
-            entity.Images = dto.ImageInfos.Select(f => Map(dto.Id, f)).ToArray();
-        }
-
-        if (dto is Trailer trailer)
-        {
-            entity.TrailerTypes = trailer.TrailerTypes?.Select(e => new BaseItemTrailerType()
-            {
-                Id = (int)e,
-                Item = entity,
-                ItemId = entity.Id
-            }).ToArray() ?? [];
-        }
-
-        // dto.Type = entity.Type;
-        // dto.Data = entity.Data;
-        entity.MediaType = dto.MediaType.ToString();
-        if (dto is IHasStartDate hasStartDate)
-        {
-            entity.StartDate = hasStartDate.StartDate;
-        }
-
-        entity.UnratedType = dto.GetBlockUnratedType().ToString();
-
-        // Fields that are present in the DB but are never actually used
-        // dto.UserDataKey = entity.UserDataKey;
-
-        if (dto is Folder folder)
-        {
-            entity.DateLastMediaAdded = folder.DateLastMediaAdded == DateTime.MinValue ? null : folder.DateLastMediaAdded;
-            entity.IsFolder = folder.IsFolder;
-        }
-
-        return entity;
-    }
-
-    private string[] GetItemValueNames(IReadOnlyList<ItemValueType> itemValueTypes, IReadOnlyList<string> withItemTypes, IReadOnlyList<string> excludeItemTypes)
-    {
-        using var context = _dbProvider.CreateDbContext();
-
-        var query = context.ItemValuesMap
-            .AsNoTracking()
-            .Where(e => itemValueTypes.Any(w => w == e.ItemValue.Type));
-        if (withItemTypes.Count > 0)
-        {
-            query = query.Where(e => withItemTypes.Contains(e.Item.Type));
-        }
-
-        if (excludeItemTypes.Count > 0)
-        {
-            query = query.Where(e => !excludeItemTypes.Contains(e.Item.Type));
-        }
-
-        // query = query.DistinctBy(e => e.CleanValue);
-        return query.Select(e => e.ItemValue)
-            .GroupBy(e => e.CleanValue)
-            .Select(e => e.OrderBy(v => v.Value).First().Value)
-            .ToArray();
-    }
-
-    private static bool TypeRequiresDeserialization(Type type)
-    {
-        return type.GetCustomAttribute<RequiresSourceSerialisationAttribute>() == null;
-    }
-
-    private BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, bool skipDeserialization = false)
-    {
-        ArgumentNullException.ThrowIfNull(baseItemEntity, nameof(baseItemEntity));
-        if (_serverConfigurationManager?.Configuration is null)
-        {
-            throw new InvalidOperationException("Server Configuration manager or configuration is null");
-        }
-
-        var typeToSerialise = GetType(baseItemEntity.Type);
-        return BaseItemRepository.DeserializeBaseItem(
-            baseItemEntity,
-            _logger,
-            _appHost,
-            skipDeserialization || (_serverConfigurationManager.Configuration.SkipDeserializationForBasicTypes && (typeToSerialise == typeof(Channel) || typeToSerialise == typeof(UserRootFolder))));
-    }
-
-    /// <summary>
-    /// Deserializes a BaseItemEntity and sets all properties.
-    /// </summary>
-    /// <param name="baseItemEntity">The DB entity.</param>
-    /// <param name="logger">Logger.</param>
-    /// <param name="appHost">The application server Host.</param>
-    /// <param name="skipDeserialization">If only mapping should be processed.</param>
-    /// <returns>A mapped BaseItem, or null if the item type is unknown.</returns>
-    public static BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost? appHost, bool skipDeserialization = false)
-    {
-        var type = GetType(baseItemEntity.Type);
-        if (type is null)
-        {
-            logger.LogWarning(
-                "Skipping item {ItemId} with unknown type '{ItemType}'. This may indicate a removed plugin or database corruption.",
-                baseItemEntity.Id,
-                baseItemEntity.Type);
-            return null;
-        }
-
-        BaseItemDto? dto = null;
-        if (TypeRequiresDeserialization(type) && baseItemEntity.Data is not null && !skipDeserialization)
-        {
-            try
-            {
-                dto = JsonSerializer.Deserialize(baseItemEntity.Data, type, JsonDefaults.Options) as BaseItemDto;
-            }
-            catch (JsonException ex)
-            {
-                logger.LogError(ex, "Error deserializing item with JSON: {Data}", baseItemEntity.Data);
-            }
-        }
-
-        if (dto is null)
-        {
-            dto = Activator.CreateInstance(type) as BaseItemDto ?? throw new InvalidOperationException("Cannot deserialize unknown type.");
-        }
-
-        return Map(baseItemEntity, dto, appHost, logger);
-    }
-
-    private QueryResult<(BaseItemDto Item, ItemCounts? ItemCounts)> GetItemValues(InternalItemsQuery filter, IReadOnlyList<ItemValueType> itemValueTypes, string returnType)
-    {
-        ArgumentNullException.ThrowIfNull(filter);
-
-        if (!filter.Limit.HasValue)
-        {
-            filter.EnableTotalRecordCount = false;
-        }
-
-        using var context = _dbProvider.CreateDbContext();
-
-        var innerQueryFilter = TranslateQuery(context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)), context, new InternalItemsQuery(filter.User)
-        {
-            ExcludeItemTypes = filter.ExcludeItemTypes,
-            IncludeItemTypes = filter.IncludeItemTypes,
-            MediaTypes = filter.MediaTypes,
-            AncestorIds = filter.AncestorIds,
-            ItemIds = filter.ItemIds,
-            TopParentIds = filter.TopParentIds,
-            ParentId = filter.ParentId,
-            IsAiring = filter.IsAiring,
-            IsMovie = filter.IsMovie,
-            IsSports = filter.IsSports,
-            IsKids = filter.IsKids,
-            IsNews = filter.IsNews,
-            IsSeries = filter.IsSeries
-        });
-        var itemValuesQuery = context.ItemValuesMap
-            .Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))
-            .Join(
-                innerQueryFilter,
-                ivm => ivm.ItemId,
-                g => g.Id,
-                (ivm, g) => ivm.ItemValue.CleanValue);
-
-        var innerQuery = PrepareItemQuery(context, filter)
-            .Where(e => e.Type == returnType)
-            .Where(e => itemValuesQuery.Contains(e.CleanName));
-
-        var outerQueryFilter = new InternalItemsQuery(filter.User)
-        {
-            IsPlayed = filter.IsPlayed,
-            IsFavorite = filter.IsFavorite,
-            IsFavoriteOrLiked = filter.IsFavoriteOrLiked,
-            IsLiked = filter.IsLiked,
-            IsLocked = filter.IsLocked,
-            NameLessThan = filter.NameLessThan,
-            NameStartsWith = filter.NameStartsWith,
-            NameStartsWithOrGreater = filter.NameStartsWithOrGreater,
-            Tags = filter.Tags,
-            OfficialRatings = filter.OfficialRatings,
-            StudioIds = filter.StudioIds,
-            GenreIds = filter.GenreIds,
-            Genres = filter.Genres,
-            Years = filter.Years,
-            NameContains = filter.NameContains,
-            SearchTerm = filter.SearchTerm,
-            ExcludeItemIds = filter.ExcludeItemIds
-        };
-
-        var masterQuery = TranslateQuery(innerQuery, context, outerQueryFilter)
-            .GroupBy(e => e.PresentationUniqueKey)
-            .Select(e => e.OrderBy(x => x.Id).FirstOrDefault())
-            .Select(e => e!.Id);
-
-        var query = context.BaseItems
-            .Include(e => e.TrailerTypes)
-            .Include(e => e.Provider)
-            .Include(e => e.LockedFields)
-            .Include(e => e.Images)
-            .Include(e => e.LinkedChildEntities)
-            .AsSingleQuery()
-            .Where(e => masterQuery.Contains(e.Id));
-
-        query = ApplyOrder(query, filter, context);
-
-        var result = new QueryResult<(BaseItemDto, ItemCounts?)>();
-        if (filter.EnableTotalRecordCount)
-        {
-            result.TotalRecordCount = query.Count();
-        }
-
-        if (filter.Limit.HasValue || filter.StartIndex.HasValue)
-        {
-            var offset = filter.StartIndex ?? 0;
-
-            if (offset > 0)
-            {
-                query = query.Skip(offset);
-            }
-
-            if (filter.Limit.HasValue)
-            {
-                query = query.Take(filter.Limit.Value);
-            }
-        }
-
-        if (filter.IncludeItemTypes.Length > 0)
-        {
-            var typeSubQuery = new InternalItemsQuery(filter.User)
-            {
-                ExcludeItemTypes = filter.ExcludeItemTypes,
-                IncludeItemTypes = filter.IncludeItemTypes,
-                MediaTypes = filter.MediaTypes,
-                AncestorIds = filter.AncestorIds,
-                ExcludeItemIds = filter.ExcludeItemIds,
-                ItemIds = filter.ItemIds,
-                TopParentIds = filter.TopParentIds,
-                ParentId = filter.ParentId,
-                IsPlayed = filter.IsPlayed
-            };
-
-            var itemCountQuery = TranslateQuery(context.BaseItems.AsNoTracking().Where(e => e.Id != EF.Constant(PlaceholderId)), context, typeSubQuery)
-                .Where(e => e.ItemValues!.Any(f => itemValueTypes!.Contains(f.ItemValue.Type)));
-
-            var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];
-            var movieTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Movie];
-            var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];
-            var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum];
-            var musicArtistTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];
-            var audioTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Audio];
-            var trailerTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Trailer];
-
-            // Get the IDs from itemCountQuery to use in the join
-            var itemIds = itemCountQuery.Select(e => e.Id);
-
-            // Rewrite query to avoid SelectMany on navigation properties (which requires SQL APPLY, not supported on SQLite)
-            // Instead, start from ItemValueMaps and join with BaseItems
-            var countsByCleanName = context.ItemValuesMap
-                .Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))
-                .Where(ivm => itemIds.Contains(ivm.ItemId))
-                .Join(
-                    context.BaseItems,
-                    ivm => ivm.ItemId,
-                    e => e.Id,
-                    (ivm, e) => new { CleanName = ivm.ItemValue.CleanValue, e.Type })
-                .GroupBy(x => new { x.CleanName, x.Type })
-                .Select(g => new { g.Key.CleanName, g.Key.Type, Count = g.Count() })
-                .GroupBy(x => x.CleanName)
-                .ToDictionary(
-                    g => g.Key,
-                    g => new ItemCounts
-                    {
-                        SeriesCount = g.Where(x => x.Type == seriesTypeName).Sum(x => x.Count),
-                        EpisodeCount = g.Where(x => x.Type == episodeTypeName).Sum(x => x.Count),
-                        MovieCount = g.Where(x => x.Type == movieTypeName).Sum(x => x.Count),
-                        AlbumCount = g.Where(x => x.Type == musicAlbumTypeName).Sum(x => x.Count),
-                        ArtistCount = g.Where(x => x.Type == musicArtistTypeName).Sum(x => x.Count),
-                        SongCount = g.Where(x => x.Type == audioTypeName).Sum(x => x.Count),
-                        TrailerCount = g.Where(x => x.Type == trailerTypeName).Sum(x => x.Count),
-                    });
-
-            result.StartIndex = filter.StartIndex ?? 0;
-            result.Items =
-            [
-                .. query
-                    .AsEnumerable()
-                    .Where(e => e is not null)
-                    .Select(e =>
-                    {
-                        var item = DeserializeBaseItem(e, filter.SkipDeserialization);
-                        countsByCleanName.TryGetValue(e.CleanName ?? string.Empty, out var itemCount);
-                        return (item, itemCount);
-                    })
-                    .Where(x => x.item is not null)
-                    .Select(x => (x.item!, x.itemCount))
-            ];
-        }
-        else
-        {
-            result.StartIndex = filter.StartIndex ?? 0;
-            result.Items =
-            [
-                .. query
-                    .AsEnumerable()
-                    .Where(e => e != null)
-                    .Select(e => DeserializeBaseItem(e, filter.SkipDeserialization))
-                    .Where(item => item != null)
-                    .Select(item => (item!, (ItemCounts?)null))
-            ];
-        }
-
-        return result;
-    }
-
-    private static void PrepareFilterQuery(InternalItemsQuery query)
-    {
-        if (query.Limit.HasValue && query.EnableGroupByMetadataKey)
-        {
-            query.Limit = query.Limit.Value + 4;
-        }
-
-        if (query.IsResumable ?? false)
-        {
-            query.IsVirtualItem = false;
-        }
-    }
-
-    private List<(ItemValueType MagicNumber, string Value)> GetItemValuesToSave(BaseItemDto item, List<string> inheritedTags)
-    {
-        var list = new List<(ItemValueType, string)>();
-
-        if (item is IHasArtist hasArtist)
-        {
-            list.AddRange(hasArtist.Artists.Select(i => ((ItemValueType)0, i)));
-        }
-
-        if (item is IHasAlbumArtist hasAlbumArtist)
-        {
-            list.AddRange(hasAlbumArtist.AlbumArtists.Select(i => (ItemValueType.AlbumArtist, i)));
-        }
-
-        list.AddRange(item.Genres.Select(i => (ItemValueType.Genre, i)));
-        list.AddRange(item.Studios.Select(i => (ItemValueType.Studios, i)));
-        list.AddRange(item.Tags.Select(i => (ItemValueType.Tags, i)));
-
-        // keywords was 5
-
-        list.AddRange(inheritedTags.Select(i => (ItemValueType.InheritedTags, i)));
-
-        // Remove all invalid values.
-        list.RemoveAll(i => string.IsNullOrWhiteSpace(i.Item2));
-
-        return list;
-    }
-
-    private static BaseItemImageInfo Map(Guid baseItemId, ItemImageInfo e)
-    {
-        return new BaseItemImageInfo()
-        {
-            ItemId = baseItemId,
-            Id = Guid.NewGuid(),
-            Path = e.Path,
-            Blurhash = e.BlurHash is null ? null : Encoding.UTF8.GetBytes(e.BlurHash),
-            DateModified = e.DateModified,
-            Height = e.Height,
-            Width = e.Width,
-            ImageType = (ImageInfoImageType)e.Type,
-            Item = null!
-        };
-    }
-
-    private static ItemImageInfo Map(BaseItemImageInfo e, IServerApplicationHost? appHost)
-    {
-        return new ItemImageInfo()
-        {
-            Path = appHost?.ExpandVirtualPath(e.Path) ?? e.Path,
-            BlurHash = e.Blurhash is null ? null : Encoding.UTF8.GetString(e.Blurhash),
-            DateModified = e.DateModified ?? DateTime.SpecifyKind(DateTime.MinValue, DateTimeKind.Utc),
-            Height = e.Height,
-            Width = e.Width,
-            Type = (ImageType)e.ImageType
-        };
-    }
-
-    private string? GetPathToSave(string path)
-    {
-        if (path is null)
-        {
-            return null;
-        }
-
-        return _appHost.ReverseVirtualPath(path);
-    }
-
-    private List<string> GetItemByNameTypesInQuery(InternalItemsQuery query)
-    {
-        var list = new List<string>();
-
-        if (IsTypeInQuery(BaseItemKind.Person, query))
-        {
-            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Person]!);
-        }
-
-        if (IsTypeInQuery(BaseItemKind.Genre, query))
-        {
-            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Genre]!);
-        }
-
-        if (IsTypeInQuery(BaseItemKind.MusicGenre, query))
-        {
-            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicGenre]!);
-        }
-
-        if (IsTypeInQuery(BaseItemKind.MusicArtist, query))
-        {
-            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]!);
-        }
-
-        if (IsTypeInQuery(BaseItemKind.Studio, query))
-        {
-            list.Add(_itemTypeLookup.BaseItemKindNames[BaseItemKind.Studio]!);
-        }
-
-        return list;
-    }
-
-    private bool IsTypeInQuery(BaseItemKind type, InternalItemsQuery query)
-    {
-        if (query.ExcludeItemTypes.Contains(type))
-        {
-            return false;
-        }
-
-        return query.IncludeItemTypes.Length == 0 || query.IncludeItemTypes.Contains(type);
-    }
-
-    private bool EnableGroupByPresentationUniqueKey(InternalItemsQuery query)
-    {
-        if (!query.GroupByPresentationUniqueKey)
-        {
-            return false;
-        }
-
-        if (query.GroupBySeriesPresentationUniqueKey)
-        {
-            return false;
-        }
-
-        if (!string.IsNullOrWhiteSpace(query.PresentationUniqueKey))
-        {
-            return false;
-        }
-
-        if (query.User is null)
-        {
-            return false;
-        }
-
-        if (query.IncludeItemTypes.Length == 0)
-        {
-            return true;
-        }
-
-        return query.IncludeItemTypes.Contains(BaseItemKind.Episode)
-            || query.IncludeItemTypes.Contains(BaseItemKind.Video)
-            || query.IncludeItemTypes.Contains(BaseItemKind.Movie)
-            || query.IncludeItemTypes.Contains(BaseItemKind.MusicVideo)
-            || query.IncludeItemTypes.Contains(BaseItemKind.Series)
-            || query.IncludeItemTypes.Contains(BaseItemKind.Season);
-    }
-
-    private IQueryable<BaseItemEntity> ApplyOrder(IQueryable<BaseItemEntity> query, InternalItemsQuery filter, JellyfinDbContext context)
-    {
-        var orderBy = filter.OrderBy.Where(e => e.OrderBy != ItemSortBy.Default).ToArray();
-        var hasSearch = !string.IsNullOrEmpty(filter.SearchTerm);
-
-        // SeriesDatePlayed requires special handling to avoid correlated subqueries.
-        // Instead of running a MAX() subquery per-row in ORDER BY, we pre-aggregate
-        // max played dates per series in one query and left-join it.
-        if (!hasSearch && orderBy.Any(o => o.OrderBy == ItemSortBy.SeriesDatePlayed))
-        {
-            return ApplySeriesDatePlayedOrder(query, filter, context, orderBy);
-        }
-
-        IOrderedQueryable<BaseItemEntity>? orderedQuery = null;
-
-        if (hasSearch)
-        {
-            var relevanceExpression = OrderMapper.MapSearchRelevanceOrder(filter.SearchTerm!);
-            orderedQuery = query.OrderBy(relevanceExpression);
-        }
-
-        if (orderBy.Length > 0)
-        {
-            var firstOrdering = orderBy[0];
-            var expression = OrderMapper.MapOrderByField(firstOrdering.OrderBy, filter, context);
-
-            if (orderedQuery is null)
-            {
-                orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending
-                    ? query.OrderBy(expression)
-                    : query.OrderByDescending(expression);
-            }
-            else
-            {
-                orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending
-                    ? orderedQuery.ThenBy(expression)
-                    : orderedQuery.ThenByDescending(expression);
-            }
-
-            if (firstOrdering.OrderBy is ItemSortBy.Default or ItemSortBy.SortName)
-            {
-                orderedQuery = firstOrdering.SortOrder == SortOrder.Ascending
-                    ? orderedQuery.ThenBy(e => e.Name)
-                    : orderedQuery.ThenByDescending(e => e.Name);
-            }
-
-            foreach (var item in orderBy.Skip(1))
-            {
-                expression = OrderMapper.MapOrderByField(item.OrderBy, filter, context);
-                orderedQuery = item.SortOrder == SortOrder.Ascending
-                    ? orderedQuery.ThenBy(expression)
-                    : orderedQuery.ThenByDescending(expression);
-            }
-        }
-
-        if (orderedQuery is null)
-        {
-            return query.OrderBy(e => e.SortName);
-        }
-
-        // Add SortName as final tiebreaker
-        if (!hasSearch && (orderBy.Length == 0 || orderBy.All(o => o.OrderBy is not ItemSortBy.SortName and not ItemSortBy.Name)))
-        {
-            orderedQuery = orderedQuery.ThenBy(e => e.SortName);
-        }
-
-        return orderedQuery;
-    }
-
-    private IQueryable<BaseItemEntity> ApplySeriesDatePlayedOrder(
-        IQueryable<BaseItemEntity> query,
-        InternalItemsQuery filter,
-        JellyfinDbContext context,
-        (ItemSortBy OrderBy, SortOrder SortOrder)[] orderBy)
-    {
-        // Pre-aggregate max played date per series key in ONE query.
-        // This generates a single: SELECT SeriesPresentationUniqueKey, MAX(LastPlayedDate) ... GROUP BY
-        // instead of a correlated subquery per outer row.
-        IQueryable<UserData> userDataQuery = filter.User is not null
-            ? context.UserData.Where(ud => ud.UserId == filter.User.Id && ud.Played)
-            : context.UserData.Where(ud => ud.Played);
-
-        var seriesMaxDates = userDataQuery
-            .Join(
-                context.BaseItems,
-                ud => ud.ItemId,
-                bi => bi.Id,
-                (ud, bi) => new { bi.SeriesPresentationUniqueKey, ud.LastPlayedDate })
-            .Where(x => x.SeriesPresentationUniqueKey != null)
-            .GroupBy(x => x.SeriesPresentationUniqueKey)
-            .Select(g => new { SeriesKey = g.Key!, MaxDate = g.Max(x => x.LastPlayedDate) });
-
-        var joined = query.LeftJoin(
-            seriesMaxDates,
-            e => e.PresentationUniqueKey,
-            s => s.SeriesKey,
-            (e, s) => new { Item = e, MaxDate = s != null ? s.MaxDate : (DateTime?)null });
-
-        var seriesSort = orderBy.First(o => o.OrderBy == ItemSortBy.SeriesDatePlayed);
-
-        return seriesSort.SortOrder == SortOrder.Ascending
-            ? joined.OrderBy(x => x.MaxDate).ThenBy(x => x.Item.SortName).Select(x => x.Item)
-            : joined.OrderByDescending(x => x.MaxDate).ThenBy(x => x.Item.SortName).Select(x => x.Item);
-    }
-
-    private IQueryable<BaseItemEntity> TranslateQuery(
-        IQueryable<BaseItemEntity> baseQuery,
-        JellyfinDbContext context,
-        InternalItemsQuery filter)
-    {
-        const int HDWidth = 1200;
-        const int UHDWidth = 3800;
-        const int UHDHeight = 2100;
-
-        var minWidth = filter.MinWidth;
-        var maxWidth = filter.MaxWidth;
-        var now = DateTime.UtcNow;
-
-        if (filter.IsHD.HasValue || filter.Is4K.HasValue)
-        {
-            bool includeSD = false;
-            bool includeHD = false;
-            bool include4K = false;
-
-            if (filter.IsHD.HasValue && !filter.IsHD.Value)
-            {
-                includeSD = true;
-            }
-
-            if (filter.IsHD.HasValue && filter.IsHD.Value)
-            {
-                includeHD = true;
-            }
-
-            if (filter.Is4K.HasValue && filter.Is4K.Value)
-            {
-                include4K = true;
-            }
-
-            baseQuery = baseQuery.Where(e =>
-                (includeSD && e.Width < HDWidth) ||
-                (includeHD && e.Width >= HDWidth && !(e.Width >= UHDWidth || e.Height >= UHDHeight)) ||
-                (include4K && (e.Width >= UHDWidth || e.Height >= UHDHeight)));
-        }
-
-        if (minWidth.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.Width >= minWidth);
-        }
-
-        if (filter.MinHeight.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.Height >= filter.MinHeight);
-        }
-
-        if (maxWidth.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.Width <= maxWidth);
-        }
-
-        if (filter.MaxHeight.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.Height <= filter.MaxHeight);
-        }
-
-        if (filter.IsLocked.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.IsLocked == filter.IsLocked);
-        }
-
-        var tags = filter.Tags.ToList();
-        var excludeTags = filter.ExcludeTags.ToList();
-
-        if (filter.IsMovie.HasValue)
-        {
-            var shouldIncludeAllMovieTypes = filter.IsMovie.Value
-                && (filter.IncludeItemTypes.Length == 0
-                    || filter.IncludeItemTypes.Contains(BaseItemKind.Movie)
-                    || filter.IncludeItemTypes.Contains(BaseItemKind.Trailer));
-
-            if (!shouldIncludeAllMovieTypes)
-            {
-                baseQuery = baseQuery.Where(e => e.IsMovie == filter.IsMovie.Value);
-            }
-        }
-
-        if (filter.IsSeries.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.IsSeries == filter.IsSeries);
-        }
-
-        if (filter.IsSports.HasValue)
-        {
-            if (filter.IsSports.Value)
-            {
-                tags.Add("Sports");
-            }
-            else
-            {
-                excludeTags.Add("Sports");
-            }
-        }
-
-        if (filter.IsNews.HasValue)
-        {
-            if (filter.IsNews.Value)
-            {
-                tags.Add("News");
-            }
-            else
-            {
-                excludeTags.Add("News");
-            }
-        }
-
-        if (filter.IsKids.HasValue)
-        {
-            if (filter.IsKids.Value)
-            {
-                tags.Add("Kids");
-            }
-            else
-            {
-                excludeTags.Add("Kids");
-            }
-        }
-
-        if (!string.IsNullOrEmpty(filter.SearchTerm))
-        {
-            var cleanedSearchTerm = filter.SearchTerm.GetCleanValue();
-            var originalSearchTerm = filter.SearchTerm;
-            if (SearchWildcardTerms.Any(f => cleanedSearchTerm.Contains(f)))
-            {
-                cleanedSearchTerm = $"%{cleanedSearchTerm.Trim('%')}%";
-                var likeSearchTerm = $"%{originalSearchTerm.Trim('%')}%";
-                baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName!, cleanedSearchTerm) || (e.OriginalTitle != null && EF.Functions.Like(e.OriginalTitle, likeSearchTerm)));
-            }
-            else
-            {
-                var likeSearchTerm = $"%{originalSearchTerm}%";
-                baseQuery = baseQuery.Where(e => e.CleanName!.Contains(cleanedSearchTerm) || (e.OriginalTitle != null && EF.Functions.Like(e.OriginalTitle, likeSearchTerm)));
-            }
-        }
-
-        if (filter.IsFolder.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.IsFolder == filter.IsFolder);
-        }
-
-        var includeTypes = filter.IncludeItemTypes;
-
-        // Only specify excluded types if no included types are specified
-        if (filter.IncludeItemTypes.Length == 0)
-        {
-            var excludeTypes = filter.ExcludeItemTypes;
-            if (excludeTypes.Length == 1)
-            {
-                if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeTypes[0], out var excludeTypeName))
-                {
-                    baseQuery = baseQuery.Where(e => e.Type != excludeTypeName);
-                }
-            }
-            else if (excludeTypes.Length > 1)
-            {
-                var excludeTypeName = new List<string>();
-                foreach (var excludeType in excludeTypes)
-                {
-                    if (_itemTypeLookup.BaseItemKindNames.TryGetValue(excludeType, out var baseItemKindName))
-                    {
-                        excludeTypeName.Add(baseItemKindName!);
-                    }
-                }
-
-                baseQuery = baseQuery.Where(e => !excludeTypeName.Contains(e.Type));
-            }
-        }
-        else
-        {
-            string[] types = includeTypes.Select(f => _itemTypeLookup.BaseItemKindNames.GetValueOrDefault(f)).Where(e => e != null).ToArray()!;
-            baseQuery = baseQuery.WhereOneOrMany(types, f => f.Type);
-        }
-
-        if (filter.ChannelIds.Count > 0)
-        {
-            baseQuery = baseQuery.Where(e => e.ChannelId != null && filter.ChannelIds.Contains(e.ChannelId.Value));
-        }
-
-        if (!filter.ParentId.IsEmpty())
-        {
-            baseQuery = baseQuery.Where(e => e.ParentId!.Value == filter.ParentId);
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.Path))
-        {
-            var pathToQuery = GetPathToSave(filter.Path);
-            baseQuery = baseQuery.Where(e => e.Path == pathToQuery);
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.PresentationUniqueKey))
-        {
-            baseQuery = baseQuery.Where(e => e.PresentationUniqueKey == filter.PresentationUniqueKey);
-        }
-
-        if (filter.MinCommunityRating.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.CommunityRating >= filter.MinCommunityRating);
-        }
-
-        if (filter.MinIndexNumber.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.IndexNumber >= filter.MinIndexNumber);
-        }
-
-        if (filter.MinParentAndIndexNumber.HasValue)
-        {
-            baseQuery = baseQuery
-                .Where(e => (e.ParentIndexNumber == filter.MinParentAndIndexNumber.Value.ParentIndexNumber && e.IndexNumber >= filter.MinParentAndIndexNumber.Value.IndexNumber) || e.ParentIndexNumber > filter.MinParentAndIndexNumber.Value.ParentIndexNumber);
-        }
-
-        if (filter.MinDateCreated.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.DateCreated >= filter.MinDateCreated);
-        }
-
-        if (filter.MinDateLastSaved.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSaved.Value);
-        }
-
-        if (filter.MinDateLastSavedForUser.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.DateLastSaved != null && e.DateLastSaved >= filter.MinDateLastSavedForUser.Value);
-        }
-
-        if (filter.IndexNumber.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.IndexNumber == filter.IndexNumber.Value);
-        }
-
-        if (filter.ParentIndexNumber.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.ParentIndexNumber == filter.ParentIndexNumber.Value);
-        }
-
-        if (filter.ParentIndexNumberNotEquals.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.ParentIndexNumber != filter.ParentIndexNumberNotEquals.Value || e.ParentIndexNumber == null);
-        }
-
-        var minEndDate = filter.MinEndDate;
-        var maxEndDate = filter.MaxEndDate;
-
-        if (filter.HasAired.HasValue)
-        {
-            if (filter.HasAired.Value)
-            {
-                maxEndDate = DateTime.UtcNow;
-            }
-            else
-            {
-                minEndDate = DateTime.UtcNow;
-            }
-        }
-
-        if (minEndDate.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.EndDate >= minEndDate);
-        }
-
-        if (maxEndDate.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.EndDate <= maxEndDate);
-        }
-
-        if (filter.MinStartDate.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.StartDate >= filter.MinStartDate.Value);
-        }
-
-        if (filter.MaxStartDate.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.StartDate <= filter.MaxStartDate.Value);
-        }
-
-        if (filter.MinPremiereDate.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.PremiereDate >= filter.MinPremiereDate.Value);
-        }
-
-        if (filter.MaxPremiereDate.HasValue)
-        {
-            baseQuery = baseQuery.Where(e => e.PremiereDate <= filter.MaxPremiereDate.Value);
-        }
-
-        if (filter.TrailerTypes.Length > 0)
-        {
-            var trailerTypes = filter.TrailerTypes.Select(e => (int)e).ToArray();
-            baseQuery = baseQuery.Where(e => e.TrailerTypes!.Any(w => trailerTypes.Contains(w.Id)));
-        }
-
-        if (filter.IsAiring.HasValue)
-        {
-            if (filter.IsAiring.Value)
-            {
-                baseQuery = baseQuery.Where(e => e.StartDate <= now && e.EndDate >= now);
-            }
-            else
-            {
-                baseQuery = baseQuery.Where(e => e.StartDate > now && e.EndDate < now);
-            }
-        }
-
-        if (filter.PersonIds.Length > 0)
-        {
-            var peopleEntityIds = context.BaseItems
-                .WhereOneOrMany(filter.PersonIds, b => b.Id)
-                .Join(
-                    context.Peoples,
-                    b => b.Name,
-                    p => p.Name,
-                    (b, p) => p.Id);
-
-            baseQuery = baseQuery
-                .Where(e => context.PeopleBaseItemMap
-                    .Any(m => m.ItemId == e.Id && peopleEntityIds.Contains(m.PeopleId)));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.Person))
-        {
-            baseQuery = baseQuery.Where(e => e.Peoples!.Any(f => f.People.Name == filter.Person));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.MinSortName))
-        {
-            // this does not makes sense.
-            // baseQuery = baseQuery.Where(e => e.SortName >= query.MinSortName);
-            // whereClauses.Add("SortName>=@MinSortName");
-            // statement?.TryBind("@MinSortName", query.MinSortName);
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.ExternalSeriesId))
-        {
-            baseQuery = baseQuery.Where(e => e.ExternalSeriesId == filter.ExternalSeriesId);
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.ExternalId))
-        {
-            baseQuery = baseQuery.Where(e => e.ExternalId == filter.ExternalId);
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.Name))
-        {
-            if (filter.UseRawName == true)
-            {
-                baseQuery = baseQuery.Where(e => e.Name == filter.Name);
-            }
-            else
-            {
-                var cleanName = filter.Name.GetCleanValue();
-                baseQuery = baseQuery.Where(e => e.CleanName == cleanName);
-            }
-        }
-
-        // These are the same, for now
-        var nameContains = filter.NameContains;
-        if (!string.IsNullOrWhiteSpace(nameContains))
-        {
-            if (SearchWildcardTerms.Any(f => nameContains.Contains(f)))
-            {
-                nameContains = $"%{nameContains.Trim('%')}%";
-                baseQuery = baseQuery.Where(e => EF.Functions.Like(e.CleanName, nameContains) || EF.Functions.Like(e.OriginalTitle, nameContains));
-            }
-            else
-            {
-                var likeNameContains = $"%{nameContains}%";
-                baseQuery = baseQuery.Where(e =>
-                                    e.CleanName!.Contains(nameContains)
-                                    || EF.Functions.Like(e.OriginalTitle, likeNameContains));
-            }
-        }
-
-        // When box set collapsing is active, defer name-range filters to after the collapse.
-        // Otherwise, items are filtered by their own name but then collapsed into a BoxSet
-        // whose name may fall in a different range (e.g. "21 Jump Street" is under "#"
-        // but its BoxSet "Jump Street Collection" should appear under "J").
-        if (filter.CollapseBoxSetItems != true)
-        {
-            baseQuery = ApplyNameFilters(baseQuery, filter);
-        }
-
-        if (filter.ImageTypes.Length > 0)
-        {
-            var imgTypes = filter.ImageTypes.Select(e => (ImageInfoImageType)e).ToArray();
-            baseQuery = baseQuery.Where(e => e.Images!.Any(w => imgTypes.Contains(w.ImageType)));
-        }
-
-        if (filter.IsLiked.HasValue)
-        {
-            var isLiked = filter.IsLiked.Value;
-            baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.Rating >= UserItemData.MinLikeValue) == isLiked);
-        }
-
-        if (filter.IsFavoriteOrLiked.HasValue)
-        {
-            var isFavoriteOrLiked = filter.IsFavoriteOrLiked.Value;
-            baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.IsFavorite) == isFavoriteOrLiked);
-        }
-
-        if (filter.IsFavorite.HasValue)
-        {
-            var isFavorite = filter.IsFavorite.Value;
-            baseQuery = baseQuery.Where(e => e.UserData!.Any(ud => ud.UserId == filter.User!.Id && ud.IsFavorite) == isFavorite);
-        }
-
-        if (filter.IsPlayed.HasValue)
-        {
-            // We should probably figure this out for all folders, but for right now, this is the only place where we need it
-            if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.Series)
-            {
-                // Get played series IDs by joining episodes to UserData via SeriesId (Guid foreign key).
-                // Don't filter episodes by TopParentIds here - the series will be filtered by baseQuery anyway.
-                // This allows the materialized list to be reused across library-scoped queries.
-                var playedSeriesIdList = context.BaseItems
-                    .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue)
-                    .Join(
-                        context.UserData.Where(ud => ud.UserId == filter.User!.Id && ud.Played),
-                        episode => episode.Id,
-                        ud => ud.ItemId,
-                        (episode, ud) => episode.SeriesId!.Value)
-                    .Distinct();
-
-                var isPlayed = filter.IsPlayed.Value;
-                baseQuery = baseQuery.Where(s => playedSeriesIdList.Contains(s.Id) == isPlayed);
-            }
-            else if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.BoxSet)
-            {
-                var boxSetIds = baseQuery.Select(e => e.Id).ToList();
-                var playedCounts = GetPlayedAndTotalCountBatch(boxSetIds, filter.User!);
-                var playedBoxSetIds = playedCounts
-                    .Where(kvp => kvp.Value.Total > 0 && kvp.Value.Played == kvp.Value.Total)
-                    .Select(kvp => kvp.Key);
-
-                var isPlayedBoxSet = filter.IsPlayed.Value;
-                baseQuery = baseQuery.Where(s => playedBoxSetIds.Contains(s.Id) == isPlayedBoxSet);
-            }
-            else
-            {
-                var playedItemIds = context.UserData
-                    .Where(ud => ud.UserId == filter.User!.Id && ud.Played)
-                    .Select(ud => ud.ItemId);
-                var isPlayedItem = filter.IsPlayed.Value;
-                baseQuery = baseQuery.Where(e => playedItemIds.Contains(e.Id) == isPlayedItem);
-            }
-        }
-
-        if (filter.IsResumable.HasValue)
-        {
-            var resumableItemIds = context.UserData
-                .Where(ud => ud.UserId == filter.User!.Id && ud.PlaybackPositionTicks > 0)
-                .Select(ud => ud.ItemId);
-            var isResumable = filter.IsResumable.Value;
-            baseQuery = baseQuery.Where(e => resumableItemIds.Contains(e.Id) == isResumable);
-        }
-
-        if (filter.ArtistIds.Length > 0)
-        {
-            baseQuery = baseQuery.WhereReferencedItemMultipleTypes(context, [ItemValueType.Artist, ItemValueType.AlbumArtist], filter.ArtistIds);
-        }
-
-        if (filter.AlbumArtistIds.Length > 0)
-        {
-            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.AlbumArtist, filter.AlbumArtistIds);
-        }
-
-        if (filter.ContributingArtistIds.Length > 0)
-        {
-            var contributingNames = context.BaseItems
-                .Where(b => filter.ContributingArtistIds.Contains(b.Id))
-                .Select(b => b.CleanName);
-
-            baseQuery = baseQuery.Where(e =>
-                e.ItemValues!.Any(ivm =>
-                    ivm.ItemValue.Type == ItemValueType.Artist &&
-                    contributingNames.Contains(ivm.ItemValue.CleanValue))
-                &&
-                !e.ItemValues!.Any(ivm =>
-                    ivm.ItemValue.Type == ItemValueType.AlbumArtist &&
-                    contributingNames.Contains(ivm.ItemValue.CleanValue)));
-        }
-
-        if (filter.AlbumIds.Length > 0)
-        {
-            var subQuery = context.BaseItems.WhereOneOrMany(filter.AlbumIds, f => f.Id);
-            baseQuery = baseQuery.Where(e => subQuery.Any(f => f.Name == e.Album));
-        }
-
-        if (filter.ExcludeArtistIds.Length > 0)
-        {
-            baseQuery = baseQuery.WhereReferencedItemMultipleTypes(context, [ItemValueType.Artist, ItemValueType.AlbumArtist], filter.ExcludeArtistIds, true);
-        }
-
-        if (filter.GenreIds.Count > 0)
-        {
-            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Genre, filter.GenreIds.ToArray());
-        }
-
-        if (filter.Genres.Count > 0)
-        {
-            var cleanGenres = filter.Genres.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueMap, string>(f => f.ItemValue.CleanValue);
-            baseQuery = baseQuery
-                    .Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Genre).Any(cleanGenres));
-        }
-
-        if (tags.Count > 0)
-        {
-            var cleanValues = tags.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueMap, string>(f => f.ItemValue.CleanValue);
-            baseQuery = baseQuery
-                    .Where(e => e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(cleanValues));
-        }
-
-        if (excludeTags.Count > 0)
-        {
-            var cleanValues = excludeTags.Select(e => e.GetCleanValue()).ToArray().OneOrManyExpressionBuilder<ItemValueMap, string>(f => f.ItemValue.CleanValue);
-            baseQuery = baseQuery
-                    .Where(e => !e.ItemValues!.AsQueryable().Where(f => f.ItemValue.Type == ItemValueType.Tags).Any(cleanValues));
-        }
-
-        if (filter.StudioIds.Length > 0)
-        {
-            baseQuery = baseQuery.WhereReferencedItem(context, ItemValueType.Studios, filter.StudioIds.ToArray());
-        }
-
-        if (filter.OfficialRatings.Length > 0)
-        {
-            var ratings = filter.OfficialRatings;
-            baseQuery = baseQuery.WhereItemOrDescendantMatches(context, e => ratings.Contains(e.OfficialRating));
-        }
-
-        Expression<Func<BaseItemEntity, bool>>? minParentalRatingFilter = null;
-        if (filter.MinParentalRating != null)
-        {
-            var min = filter.MinParentalRating;
-            var minScore = min.Score;
-            var minSubScore = min.SubScore ?? 0;
-
-            minParentalRatingFilter = e =>
-                e.InheritedParentalRatingValue == null ||
-                e.InheritedParentalRatingValue > minScore ||
-                (e.InheritedParentalRatingValue == minScore && (e.InheritedParentalRatingSubValue ?? 0) >= minSubScore);
-        }
-
-        Expression<Func<BaseItemEntity, bool>>? maxParentalRatingFilter = null;
-        if (filter.MaxParentalRating != null)
-        {
-            maxParentalRatingFilter = BuildMaxParentalRatingFilter(context, filter.MaxParentalRating);
-        }
-
-        if (filter.HasParentalRating ?? false)
-        {
-            if (minParentalRatingFilter != null)
-            {
-                baseQuery = baseQuery.Where(minParentalRatingFilter);
-            }
-
-            if (maxParentalRatingFilter != null)
-            {
-                baseQuery = baseQuery.Where(maxParentalRatingFilter);
-            }
-        }
-        else if (filter.BlockUnratedItems.Length > 0)
-        {
-            var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();
-            Expression<Func<BaseItemEntity, bool>> unratedItemFilter = e => e.InheritedParentalRatingValue != null || !unratedItemTypes.Contains(e.UnratedType);
-
-            if (minParentalRatingFilter != null && maxParentalRatingFilter != null)
-            {
-                baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter.And(maxParentalRatingFilter)));
-            }
-            else if (minParentalRatingFilter != null)
-            {
-                baseQuery = baseQuery.Where(unratedItemFilter.And(minParentalRatingFilter));
-            }
-            else if (maxParentalRatingFilter != null)
-            {
-                baseQuery = baseQuery.Where(unratedItemFilter.And(maxParentalRatingFilter));
-            }
-            else
-            {
-                baseQuery = baseQuery.Where(unratedItemFilter);
-            }
-        }
-        else if (minParentalRatingFilter != null || maxParentalRatingFilter != null)
-        {
-            if (minParentalRatingFilter != null)
-            {
-                baseQuery = baseQuery.Where(minParentalRatingFilter);
-            }
-
-            if (maxParentalRatingFilter != null)
-            {
-                baseQuery = baseQuery.Where(maxParentalRatingFilter);
-            }
-        }
-        else if (!filter.HasParentalRating ?? false)
-        {
-            baseQuery = baseQuery
-                .Where(e => e.InheritedParentalRatingValue == null);
-        }
-
-        if (filter.HasOfficialRating.HasValue)
-        {
-            Expression<Func<BaseItemEntity, bool>> hasRating =
-                e => e.OfficialRating != null && e.OfficialRating != string.Empty;
-
-            baseQuery = filter.HasOfficialRating.Value
-                ? baseQuery.WhereItemOrDescendantMatches(context, hasRating)
-                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasRating);
-        }
-
-        if (filter.HasOverview.HasValue)
-        {
-            if (filter.HasOverview.Value)
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.Overview != null && e.Overview != string.Empty);
-            }
-            else
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.Overview == null || e.Overview == string.Empty);
-            }
-        }
-
-        if (filter.HasOwnerId.HasValue)
-        {
-            if (filter.HasOwnerId.Value)
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.OwnerId != null);
-            }
-            else
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.OwnerId == null);
-            }
-        }
-        else if (filter.OwnerIds.Length == 0 && filter.ExtraTypes.Length == 0 && !filter.IncludeOwnedItems)
-        {
-            // Exclude alternate versions from general queries. Alternate versions have
-            // OwnerId set (pointing to their primary) but no ExtraType.
-            // Extras (trailers, etc.) also have OwnerId but DO have ExtraType set - keep those.
-            baseQuery = baseQuery.Where(e => e.OwnerId == null || e.ExtraType != null);
-        }
-
-        if (filter.OwnerIds.Length > 0)
-        {
-            baseQuery = baseQuery.Where(e => e.OwnerId != null && filter.OwnerIds.Contains(e.OwnerId.Value));
-        }
-
-        if (filter.ExtraTypes.Length > 0)
-        {
-            // Convert ExtraType enum to BaseItemExtraType enum via int cast (same underlying values)
-            var extraTypeValues = filter.ExtraTypes.Select(e => (BaseItemExtraType?)(int)e).ToArray();
-            baseQuery = baseQuery.Where(e => e.ExtraType != null && extraTypeValues.Contains(e.ExtraType));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.HasNoAudioTrackWithLanguage))
-        {
-            var lang = filter.HasNoAudioTrackWithLanguage;
-            var foldersWithAudio = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStreamTypeEntity.Audio, lang));
-
-            baseQuery = baseQuery
-                .Where(e =>
-                    (!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Audio && ms.Language == lang))
-                    || (e.IsFolder && !foldersWithAudio.Contains(e.Id)));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.HasNoInternalSubtitleTrackWithLanguage))
-        {
-            var lang = filter.HasNoInternalSubtitleTrackWithLanguage;
-            var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang, IsExternal: false));
-
-            baseQuery = baseQuery
-                .Where(e =>
-                    (!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && !ms.IsExternal && ms.Language == lang))
-                    || (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.HasNoExternalSubtitleTrackWithLanguage))
-        {
-            var lang = filter.HasNoExternalSubtitleTrackWithLanguage;
-            var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang, IsExternal: true));
-
-            baseQuery = baseQuery
-                .Where(e =>
-                    (!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && ms.IsExternal && ms.Language == lang))
-                    || (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.HasNoSubtitleTrackWithLanguage))
-        {
-            var lang = filter.HasNoSubtitleTrackWithLanguage;
-            var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasMediaStreamType(MediaStreamTypeEntity.Subtitle, lang));
-
-            baseQuery = baseQuery
-                .Where(e =>
-                    (!e.IsFolder && !e.MediaStreams!.Any(ms => ms.StreamType == MediaStreamTypeEntity.Subtitle && ms.Language == lang))
-                    || (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));
-        }
-
-        if (filter.HasSubtitles.HasValue)
-        {
-            var hasSubtitles = filter.HasSubtitles.Value;
-            var foldersWithSubtitles = DescendantQueryHelper.GetFolderIdsMatching(context, new HasSubtitles());
-            if (hasSubtitles)
-            {
-                baseQuery = baseQuery
-                    .Where(e =>
-                        (!e.IsFolder && e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle))
-                        || (e.IsFolder && foldersWithSubtitles.Contains(e.Id)));
-            }
-            else
-            {
-                baseQuery = baseQuery
-                    .Where(e =>
-                        (!e.IsFolder && !e.MediaStreams!.Any(f => f.StreamType == MediaStreamTypeEntity.Subtitle))
-                        || (e.IsFolder && !foldersWithSubtitles.Contains(e.Id)));
-            }
-        }
-
-        if (filter.HasChapterImages.HasValue)
-        {
-            var hasChapterImages = filter.HasChapterImages.Value;
-            var foldersWithChapterImages = DescendantQueryHelper.GetFolderIdsMatching(context, new HasChapterImages());
-            if (hasChapterImages)
-            {
-                baseQuery = baseQuery
-                    .Where(e =>
-                        (!e.IsFolder && e.Chapters!.Any(f => f.ImagePath != null))
-                        || (e.IsFolder && foldersWithChapterImages.Contains(e.Id)));
-            }
-            else
-            {
-                baseQuery = baseQuery
-                    .Where(e =>
-                        (!e.IsFolder && !e.Chapters!.Any(f => f.ImagePath != null))
-                        || (e.IsFolder && !foldersWithChapterImages.Contains(e.Id)));
-            }
-        }
-
-        if (filter.HasDeadParentId.HasValue && filter.HasDeadParentId.Value)
-        {
-            baseQuery = baseQuery
-                .Where(e => e.ParentId.HasValue && !context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Any(f => f.Id == e.ParentId.Value));
-        }
-
-        if (filter.IsDeadArtist.HasValue && filter.IsDeadArtist.Value)
-        {
-            baseQuery = baseQuery
-                    .Where(e => !context.ItemValues.Where(f => _getAllArtistsValueTypes.Contains(f.Type)).Any(f => f.Value == e.Name));
-        }
-
-        if (filter.IsDeadStudio.HasValue && filter.IsDeadStudio.Value)
-        {
-            baseQuery = baseQuery
-                    .Where(e => !context.ItemValues.Where(f => _getStudiosValueTypes.Contains(f.Type)).Any(f => f.Value == e.Name));
-        }
-
-        if (filter.IsDeadGenre.HasValue && filter.IsDeadGenre.Value)
-        {
-            baseQuery = baseQuery
-                    .Where(e => !context.ItemValues.Where(f => _getGenreValueTypes.Contains(f.Type)).Any(f => f.Value == e.Name));
-        }
-
-        if (filter.IsDeadPerson.HasValue && filter.IsDeadPerson.Value)
-        {
-            baseQuery = baseQuery
-                .Where(e => !context.Peoples.Any(f => f.Name == e.Name));
-        }
-
-        if (filter.Years.Length > 0)
-        {
-            baseQuery = baseQuery.WhereOneOrMany(filter.Years, e => e.ProductionYear!.Value);
-        }
-
-        var isVirtualItem = filter.IsVirtualItem ?? filter.IsMissing;
-        if (isVirtualItem.HasValue)
-        {
-            baseQuery = baseQuery
-                .Where(e => e.IsVirtualItem == isVirtualItem.Value);
-        }
-
-        if (filter.IsSpecialSeason.HasValue)
-        {
-            if (filter.IsSpecialSeason.Value)
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.IndexNumber == 0);
-            }
-            else
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.IndexNumber != 0);
-            }
-        }
-
-        if (filter.IsUnaired.HasValue)
-        {
-            if (filter.IsUnaired.Value)
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.PremiereDate >= now);
-            }
-            else
-            {
-                baseQuery = baseQuery
-                    .Where(e => e.PremiereDate < now);
-            }
-        }
-
-        if (filter.MediaTypes.Length > 0)
-        {
-            var mediaTypes = filter.MediaTypes.Select(f => f.ToString()).ToArray();
-            baseQuery = baseQuery.WhereOneOrMany(mediaTypes, e => e.MediaType);
-        }
-
-        if (filter.ItemIds.Length > 0)
-        {
-            baseQuery = baseQuery.WhereOneOrMany(filter.ItemIds, e => e.Id);
-        }
-
-        if (filter.ExcludeItemIds.Length > 0)
-        {
-            baseQuery = baseQuery
-                .Where(e => !filter.ExcludeItemIds.Contains(e.Id));
-        }
-
-        if (filter.ExcludeProviderIds is not null && filter.ExcludeProviderIds.Count > 0)
-        {
-            var exclude = filter.ExcludeProviderIds.Select(e => $"{e.Key}:{e.Value}").ToArray();
-            baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.All(f => !exclude.Contains(f)));
-        }
-
-        if (filter.HasAnyProviderId is not null && filter.HasAnyProviderId.Count > 0)
-        {
-            // Allow setting a null or empty value to get all items that have the specified provider set.
-            var includeAny = filter.HasAnyProviderId.Where(e => string.IsNullOrEmpty(e.Value)).Select(e => e.Key).ToArray();
-            if (includeAny.Length > 0)
-            {
-                baseQuery = baseQuery.Where(e => e.Provider!.Any(f => includeAny.Contains(f.ProviderId)));
-            }
-
-            var includeSelected = filter.HasAnyProviderId.Where(e => !string.IsNullOrEmpty(e.Value)).Select(e => $"{e.Key}:{e.Value}").ToArray();
-            if (includeSelected.Length > 0)
-            {
-                baseQuery = baseQuery.Where(e => e.Provider!.Select(f => f.ProviderId + ":" + f.ProviderValue)!.Any(f => includeSelected.Contains(f)));
-            }
-        }
-
-        if (filter.HasImdbId.HasValue)
-        {
-            baseQuery = filter.HasImdbId.Value
-                ? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == ImdbProviderName))
-                : baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != ImdbProviderName));
-        }
-
-        if (filter.HasTmdbId.HasValue)
-        {
-            baseQuery = filter.HasTmdbId.Value
-                ? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == TmdbProviderName))
-                : baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != TmdbProviderName));
-        }
-
-        if (filter.HasTvdbId.HasValue)
-        {
-            baseQuery = filter.HasTvdbId.Value
-                ? baseQuery.Where(e => e.Provider!.Any(f => f.ProviderId.ToLower() == TvdbProviderName))
-                : baseQuery.Where(e => e.Provider!.All(f => f.ProviderId.ToLower() != TvdbProviderName));
-        }
-
-        var queryTopParentIds = filter.TopParentIds;
-
-        if (queryTopParentIds.Length > 0)
-        {
-            var includedItemByNameTypes = GetItemByNameTypesInQuery(filter);
-            var enableItemsByName = (filter.IncludeItemsByName ?? false) && includedItemByNameTypes.Count > 0;
-            if (enableItemsByName && includedItemByNameTypes.Count > 0)
-            {
-                baseQuery = baseQuery.Where(e => includedItemByNameTypes.Contains(e.Type) || queryTopParentIds.Any(w => w == e.TopParentId!.Value));
-            }
-            else
-            {
-                baseQuery = baseQuery.WhereOneOrMany(queryTopParentIds, e => e.TopParentId!.Value);
-            }
-        }
-
-        if (filter.AncestorIds.Length > 0)
-        {
-            var ancestorFilter = filter.AncestorIds.OneOrManyExpressionBuilder<AncestorId, Guid>(f => f.ParentItemId);
-            baseQuery = baseQuery.Where(e => e.Parents!.AsQueryable().Any(ancestorFilter));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.AncestorWithPresentationUniqueKey))
-        {
-            baseQuery = baseQuery
-                .Where(e => context.BaseItems.Where(e => e.Id != EF.Constant(PlaceholderId)).Where(f => f.PresentationUniqueKey == filter.AncestorWithPresentationUniqueKey).Any(f => f.Children!.Any(w => w.ItemId == e.Id)));
-        }
-
-        if (!string.IsNullOrWhiteSpace(filter.SeriesPresentationUniqueKey))
-        {
-            baseQuery = baseQuery
-                .Where(e => e.SeriesPresentationUniqueKey == filter.SeriesPresentationUniqueKey);
-        }
-
-        if (filter.ExcludeInheritedTags.Length > 0)
-        {
-            var excludedTags = filter.ExcludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();
-            baseQuery = baseQuery.Where(e =>
-                !context.ItemValuesMap.Any(f =>
-                    f.ItemValue.Type == ItemValueType.Tags
-                    && excludedTags.Contains(f.ItemValue.CleanValue)
-                    && (f.ItemId == e.Id
-                        || (e.SeriesId.HasValue && f.ItemId == e.SeriesId.Value)
-                        || e.Parents!.Any(p => f.ItemId == p.ParentItemId)
-                        || (e.TopParentId.HasValue && f.ItemId == e.TopParentId.Value))));
-        }
-
-        if (filter.IncludeInheritedTags.Length > 0)
-        {
-            var includeTags = filter.IncludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();
-            var isPlaylistOnlyQuery = includeTypes.Length == 1 && includeTypes.FirstOrDefault() == BaseItemKind.Playlist;
-            baseQuery = baseQuery.Where(e =>
-                context.ItemValuesMap.Any(f =>
-                    f.ItemValue.Type == ItemValueType.Tags
-                    && includeTags.Contains(f.ItemValue.CleanValue)
-                    && (f.ItemId == e.Id
-                        || (e.SeriesId.HasValue && f.ItemId == e.SeriesId.Value)
-                        || e.Parents!.Any(p => f.ItemId == p.ParentItemId)
-                        || (e.TopParentId.HasValue && f.ItemId == e.TopParentId.Value)))
-
-                // A playlist should be accessible to its owner regardless of allowed tags
-                || (isPlaylistOnlyQuery && e.Data!.Contains($"OwnerUserId\":\"{filter.User!.Id:N}\"")));
-        }
-
-        if (filter.SeriesStatuses.Length > 0)
-        {
-            var seriesStatus = filter.SeriesStatuses.Select(e => e.ToString()).ToArray();
-            baseQuery = baseQuery
-                .Where(e => seriesStatus.Any(f => e.Data!.Contains(f)));
-        }
-
-        if (filter.BoxSetLibraryFolders.Length > 0)
-        {
-            var boxsetFolders = filter.BoxSetLibraryFolders.Select(e => e.ToString("N", CultureInfo.InvariantCulture)).ToArray();
-            baseQuery = baseQuery
-                .Where(e => boxsetFolders.Any(f => e.Data!.Contains(f)));
-        }
-
-        if (filter.VideoTypes.Length > 0)
-        {
-            var videoTypeBs = filter.VideoTypes.Select(vt => $"\"VideoType\":\"{vt}\"").ToArray();
-            Expression<Func<BaseItemEntity, bool>> hasVideoType = e => videoTypeBs.Any(f => e.Data!.Contains(f));
-            baseQuery = baseQuery.WhereItemOrDescendantMatches(context, hasVideoType);
-        }
-
-        if (filter.Is3D.HasValue)
-        {
-            Expression<Func<BaseItemEntity, bool>> is3D = e => e.Data!.Contains("Video3DFormat");
-
-            baseQuery = filter.Is3D.Value
-                ? baseQuery.WhereItemOrDescendantMatches(context, is3D)
-                : baseQuery.WhereNeitherItemNorDescendantMatches(context, is3D);
-        }
-
-        if (filter.IsPlaceHolder.HasValue)
-        {
-            Expression<Func<BaseItemEntity, bool>> isPlaceHolder = e => e.Data!.Contains("IsPlaceHolder\":true");
-
-            baseQuery = filter.IsPlaceHolder.Value
-                ? baseQuery.WhereItemOrDescendantMatches(context, isPlaceHolder)
-                : baseQuery.WhereNeitherItemNorDescendantMatches(context, isPlaceHolder);
-        }
-
-        if (filter.HasSpecialFeature.HasValue)
-        {
-            var itemsWithExtras = context.BaseItems
-                .Where(extra => extra.OwnerId != null
-                    && extra.ExtraType != null
-                    && extra.ExtraType != BaseItemExtraType.Unknown
-                    && extra.ExtraType != BaseItemExtraType.Trailer
-                    && extra.ExtraType != BaseItemExtraType.ThemeSong
-                    && extra.ExtraType != BaseItemExtraType.ThemeVideo)
-                .Select(extra => extra.OwnerId!.Value)
-                .Distinct();
-
-            Expression<Func<BaseItemEntity, bool>> hasExtras = e => itemsWithExtras.Contains(e.Id);
-
-            baseQuery = filter.HasSpecialFeature.Value
-                ? baseQuery.WhereItemOrDescendantMatches(context, hasExtras)
-                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasExtras);
-        }
-
-        if (filter.HasTrailer.HasValue)
-        {
-            var trailerOwnerIds = context.BaseItems
-                .Where(extra => extra.ExtraType == BaseItemExtraType.Trailer && extra.OwnerId != null)
-                .Select(extra => extra.OwnerId!.Value);
-
-            Expression<Func<BaseItemEntity, bool>> hasTrailer = e => trailerOwnerIds.Contains(e.Id);
-
-            baseQuery = filter.HasTrailer.Value
-                ? baseQuery.WhereItemOrDescendantMatches(context, hasTrailer)
-                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasTrailer);
-        }
-
-        if (filter.HasThemeSong.HasValue)
-        {
-            var themeSongOwnerIds = context.BaseItems
-                .Where(extra => extra.ExtraType == BaseItemExtraType.ThemeSong && extra.OwnerId != null)
-                .Select(extra => extra.OwnerId!.Value);
-
-            Expression<Func<BaseItemEntity, bool>> hasThemeSong = e => themeSongOwnerIds.Contains(e.Id);
-
-            baseQuery = filter.HasThemeSong.Value
-                ? baseQuery.WhereItemOrDescendantMatches(context, hasThemeSong)
-                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasThemeSong);
-        }
-
-        if (filter.HasThemeVideo.HasValue)
-        {
-            var themeVideoOwnerIds = context.BaseItems
-                .Where(extra => extra.ExtraType == BaseItemExtraType.ThemeVideo && extra.OwnerId != null)
-                .Select(extra => extra.OwnerId!.Value);
-
-            Expression<Func<BaseItemEntity, bool>> hasThemeVideo = e => themeVideoOwnerIds.Contains(e.Id);
-
-            baseQuery = filter.HasThemeVideo.Value
-                ? baseQuery.WhereItemOrDescendantMatches(context, hasThemeVideo)
-                : baseQuery.WhereNeitherItemNorDescendantMatches(context, hasThemeVideo);
-        }
-
-        if (filter.AiredDuringSeason.HasValue)
-        {
-            var seasonNumber = filter.AiredDuringSeason.Value;
-            if (seasonNumber < 1)
-            {
-                baseQuery = baseQuery.Where(e => e.ParentIndexNumber == seasonNumber);
-            }
-            else
-            {
-                var seasonStr = seasonNumber.ToString(CultureInfo.InvariantCulture);
-                baseQuery = baseQuery.Where(e =>
-                    e.ParentIndexNumber == seasonNumber
-                    || (e.Data != null && (
-                        e.Data.Contains("\"AirsAfterSeasonNumber\":" + seasonStr)
-                        || e.Data.Contains("\"AirsBeforeSeasonNumber\":" + seasonStr))));
-            }
-        }
-
-        if (filter.AdjacentTo.HasValue && !filter.AdjacentTo.Value.IsEmpty())
-        {
-            var adjacentToId = filter.AdjacentTo.Value;
-            var targetItem = context.BaseItems.Where(e => e.Id == adjacentToId).Select(e => new { e.SortName, e.Id }).FirstOrDefault();
-            if (targetItem is not null)
-            {
-                var targetSortName = targetItem.SortName ?? string.Empty;
-
-                // Fetch both prev and next adjacent items in a single query using Concat (UNION ALL).
-                var adjacentIds = context.BaseItems
-                    .Where(e => string.Compare(e.SortName, targetSortName) < 0)
-                    .OrderByDescending(e => e.SortName)
-                    .Select(e => e.Id)
-                    .Take(1)
-                    .Concat(
-                        context.BaseItems
-                            .Where(e => string.Compare(e.SortName, targetSortName) > 0)
-                            .OrderBy(e => e.SortName)
-                            .Select(e => e.Id)
-                            .Take(1))
-                    .ToList();
-
-                adjacentIds.Add(adjacentToId);
-                baseQuery = baseQuery.Where(e => adjacentIds.Contains(e.Id));
-            }
-        }
-
-        return baseQuery;
-    }
-
-    /// <inheritdoc/>
-    public async Task<bool> ItemExistsAsync(Guid id)
-    {
-        var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
-        await using (dbContext.ConfigureAwait(false))
-        {
-            return await dbContext.BaseItems.AnyAsync(f => f.Id == id).ConfigureAwait(false);
-        }
-    }
-
-    /// <inheritdoc/>
-    public bool GetIsPlayed(User user, Guid id, bool recursive)
-    {
-        using var dbContext = _dbProvider.CreateDbContext();
-
-        if (recursive)
-        {
-            var descendantIds = DescendantQueryHelper.GetAllDescendantIds(dbContext, id);
-
-            return dbContext.BaseItems
-                    .Where(e => descendantIds.Contains(e.Id) && !e.IsFolder && !e.IsVirtualItem)
-                    .All(f => f.UserData!.Any(e => e.UserId == user.Id && e.Played));
-        }
-
-        return dbContext.BaseItems.Where(e => e.ParentId == id).All(f => f.UserData!.Any(e => e.UserId == user.Id && e.Played));
-    }
-
-    /// <inheritdoc/>
-    public int GetPlayedCount(InternalItemsQuery filter, Guid ancestorId)
-    {
-        ArgumentNullException.ThrowIfNull(filter.User);
-        using var dbContext = _dbProvider.CreateDbContext();
-
-        var baseQuery = BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
-        return baseQuery.Count(b => b.UserData!.Any(u => u.UserId == filter.User.Id && u.Played));
-    }
-
-    /// <inheritdoc/>
-    public int GetTotalCount(InternalItemsQuery filter, Guid ancestorId)
-    {
-        using var dbContext = _dbProvider.CreateDbContext();
-
-        var baseQuery = BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
-        return baseQuery.Count();
-    }
-
-    /// <inheritdoc/>
-    public (int Played, int Total) GetPlayedAndTotalCount(InternalItemsQuery filter, Guid ancestorId)
-    {
-        ArgumentNullException.ThrowIfNull(filter);
-        ArgumentNullException.ThrowIfNull(filter.User);
-        using var dbContext = _dbProvider.CreateDbContext();
-
-        var baseQuery = BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
-        return GetPlayedAndTotalCountFromQuery(baseQuery, filter.User.Id);
-    }
-
-    /// <inheritdoc/>
-    public (int Played, int Total) GetPlayedAndTotalCountFromLinkedChildren(InternalItemsQuery filter, Guid parentId)
-    {
-        ArgumentNullException.ThrowIfNull(filter);
-        ArgumentNullException.ThrowIfNull(filter.User);
-        using var dbContext = _dbProvider.CreateDbContext();
-
-        var allDescendantIds = DescendantQueryHelper.GetAllDescendantIds(dbContext, parentId);
-        var baseQuery = dbContext.BaseItems
-            .Where(b => allDescendantIds.Contains(b.Id) && !b.IsFolder && !b.IsVirtualItem);
-        baseQuery = ApplyAccessFiltering(dbContext, baseQuery, filter);
-
-        return GetPlayedAndTotalCountFromQuery(baseQuery, filter.User.Id);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user)
-    {
-        ArgumentNullException.ThrowIfNull(folderIds);
-        ArgumentNullException.ThrowIfNull(user);
-
-        if (folderIds.Count == 0)
-        {
-            return new Dictionary<Guid, (int Played, int Total)>();
-        }
-
-        using var dbContext = _dbProvider.CreateDbContext();
-        var folderIdsArray = folderIds.ToArray();
-        var filter = new InternalItemsQuery(user);
-        var userId = user.Id;
-
-        // Access-filtered leaf items (non-folder, non-virtual)
-        var leafItems = dbContext.BaseItems
-            .Where(b => !b.IsFolder && !b.IsVirtualItem);
-        leafItems = ApplyAccessFiltering(dbContext, leafItems, filter);
-
-        // Pre-compute played status to avoid repeating the subquery in each path
-        var playedLeafItems = leafItems
-            .Select(b => new { b.Id, Played = b.UserData!.Any(ud => ud.UserId == userId && ud.Played) });
-
-        // Descendants via AncestorIds (regular folders: Series → Episodes, etc.)
-        var ancestorLeaves = dbContext.AncestorIds
-            .WhereOneOrMany(folderIdsArray, a => a.ParentItemId)
-            .Join(
-                playedLeafItems,
-                a => a.ItemId,
-                b => b.Id,
-                (a, b) => new { FolderId = a.ParentItemId, b.Id, b.Played });
-
-        // Direct non-folder linked children (BoxSets → Movies, etc.)
-        var linkedLeaves = dbContext.LinkedChildren
-            .WhereOneOrMany(folderIdsArray, lc => lc.ParentId)
-            .Join(
-                playedLeafItems,
-                lc => lc.ChildId,
-                b => b.Id,
-                (lc, b) => new { FolderId = lc.ParentId, b.Id, b.Played });
-
-        // Linked folder children's descendants (BoxSets → Series → Episodes)
-        var linkedFolderLeaves = dbContext.LinkedChildren
-            .WhereOneOrMany(folderIdsArray, lc => lc.ParentId)
-            .Join(
-                dbContext.BaseItems.Where(b => b.IsFolder),
-                lc => lc.ChildId,
-                b => b.Id,
-                (lc, b) => new { lc.ParentId, FolderChildId = b.Id })
-            .Join(
-                dbContext.AncestorIds,
-                x => x.FolderChildId,
-                a => a.ParentItemId,
-                (x, a) => new { x.ParentId, DescendantId = a.ItemId })
-            .Join(
-                playedLeafItems,
-                x => x.DescendantId,
-                b => b.Id,
-                (x, b) => new { FolderId = x.ParentId, b.Id, b.Played });
-
-        // Union all paths and aggregate per folder
-        // Distinct counts ensure items reachable through multiple paths are counted once
-        var results = ancestorLeaves
-            .Union(linkedLeaves)
-            .Union(linkedFolderLeaves)
-            .GroupBy(x => x.FolderId)
-            .Select(g => new
-            {
-                FolderId = g.Key,
-                Total = g.Select(x => x.Id).Distinct().Count(),
-                Played = g.Where(x => x.Played).Select(x => x.Id).Distinct().Count()
-            })
-            .ToDictionary(x => x.FolderId, x => (x.Played, x.Total));
-
-        return results;
-    }
-
-    /// <inheritdoc/>
-    public IReadOnlyList<Guid> GetLinkedChildrenIds(Guid parentId, int? childType = null)
-    {
-        using var dbContext = _dbProvider.CreateDbContext();
-
-        var query = dbContext.LinkedChildren
-            .Where(lc => lc.ParentId.Equals(parentId));
-
-        if (childType.HasValue)
-        {
-            query = query.Where(lc => (int)lc.ChildType == childType.Value);
-        }
-
-        return query
-            .OrderBy(lc => lc.SortOrder)
-            .Select(lc => lc.ChildId)
-            .ToList();
-    }
-
-    private static (int Played, int Total) GetPlayedAndTotalCountFromQuery(IQueryable<BaseItemEntity> query, Guid userId)
-    {
-        // GroupBy with a constant key aggregates all rows into a single group for server-side counting.
-        // OrderBy(g => g.Key) is required before FirstOrDefault to suppress EF Core warnings
-        // about unpredictable results when using FirstOrDefault without an explicit ordering.
-        var result = query
-            .Select(b => b.UserData!.Any(u => u.UserId == userId && u.Played))
-            .GroupBy(_ => 1)
-            .OrderBy(g => g.Key)
-            .Select(g => new
-            {
-                Total = g.Count(),
-                Played = g.Count(isPlayed => isPlayed)
-            })
-            .FirstOrDefault();
-
-        return result is null ? (0, 0) : (result.Played, result.Total);
-    }
-
-    /// <inheritdoc/>
-    public Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId)
-    {
-        ArgumentNullException.ThrowIfNull(parentIds);
-
-        if (parentIds.Count == 0)
-        {
-            return new Dictionary<Guid, int>();
-        }
-
-        using var dbContext = _dbProvider.CreateDbContext();
-
-        // Convert to array for EF Core Contains support
-        var parentIdsArray = parentIds.ToArray();
-
-        // Count hierarchical children (immediate children via ParentId)
-        var hierarchicalCounts = dbContext.BaseItems
-            .Where(b => b.ParentId.HasValue && parentIdsArray.Contains(b.ParentId.Value))
-            .GroupBy(b => b.ParentId!.Value)
-            .Select(g => new { ParentId = g.Key, Count = g.Count() })
-            .ToDictionary(x => x.ParentId, x => x.Count);
-
-        // Count linked children (BoxSets, Playlists, etc.)
-        var linkedCounts = dbContext.LinkedChildren
-            .Where(lc => parentIdsArray.Contains(lc.ParentId))
-            .GroupBy(lc => lc.ParentId)
-            .Select(g => new { ParentId = g.Key, Count = g.Count() })
-            .ToDictionary(x => x.ParentId, x => x.Count);
-
-        // Merge results
-        var result = new Dictionary<Guid, int>();
-        foreach (var parentId in parentIds)
-        {
-            var hierarchicalCount = hierarchicalCounts.GetValueOrDefault(parentId, 0);
-            var linkedCount = linkedCounts.GetValueOrDefault(parentId, 0);
-
-            // If there are linked children, use that count (matches Folder.GetChildCount logic)
-            // Otherwise use hierarchical count
-            result[parentId] = linkedCount > 0 ? linkedCount : hierarchicalCount;
-        }
-
-        return result;
-    }
-
-    /// <summary>
-    /// Builds a query for descendants of an ancestor with user access filtering applied.
-    /// Uses recursive CTE to traverse both hierarchical (AncestorIds) and linked (LinkedChildren) relationships.
-    /// </summary>
-    private IQueryable<BaseItemEntity> BuildAccessFilteredDescendantsQuery(
-        JellyfinDbContext context,
-        InternalItemsQuery filter,
-        Guid ancestorId)
-    {
-        // Use recursive CTE to get all descendants (hierarchical and linked)
-        var allDescendantIds = DescendantQueryHelper.GetAllDescendantIds(context, ancestorId);
-
-        var baseQuery = context.BaseItems
-            .Where(b => allDescendantIds.Contains(b.Id) && !b.IsFolder && !b.IsVirtualItem);
-
-        return ApplyAccessFiltering(context, baseQuery, filter);
-    }
-
-    /// <summary>
-    /// Applies user access filtering to a query.
-    /// Includes TopParentIds, parental rating, and tag filtering.
-    /// </summary>
-    private IQueryable<BaseItemEntity> ApplyAccessFiltering(
-        JellyfinDbContext context,
-        IQueryable<BaseItemEntity> baseQuery,
-        InternalItemsQuery filter)
-    {
-        // Apply TopParentIds filtering (library folder access)
-        if (filter.TopParentIds.Length > 0)
-        {
-            var topParentIds = filter.TopParentIds;
-            baseQuery = baseQuery.Where(e => topParentIds.Contains(e.TopParentId!.Value));
-        }
-
-        // Apply parental rating filtering
-        if (filter.MaxParentalRating is not null)
-        {
-            baseQuery = baseQuery.Where(BuildMaxParentalRatingFilter(context, filter.MaxParentalRating));
-        }
-
-        // Apply block unrated items filtering
-        if (filter.BlockUnratedItems.Length > 0)
-        {
-            var unratedItemTypes = filter.BlockUnratedItems.Select(f => f.ToString()).ToArray();
-            baseQuery = baseQuery.Where(e =>
-                e.InheritedParentalRatingValue != null || !unratedItemTypes.Contains(e.UnratedType));
-        }
-
-        // Apply excluded tags filtering (blocked tags)
-        if (filter.ExcludeInheritedTags.Length > 0)
-        {
-            var excludedTags = filter.ExcludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();
-            baseQuery = baseQuery.Where(e =>
-                !context.ItemValuesMap.Any(f =>
-                    f.ItemValue.Type == ItemValueType.Tags
-                    && excludedTags.Contains(f.ItemValue.CleanValue)
-                    && (f.ItemId == e.Id
-                        || (e.SeriesId.HasValue && f.ItemId == e.SeriesId.Value)
-                        || e.Parents!.Any(p => f.ItemId == p.ParentItemId)
-                        || (e.TopParentId.HasValue && f.ItemId == e.TopParentId.Value))));
-        }
-
-        // Apply included tags filtering (allowed tags - item must have at least one)
-        if (filter.IncludeInheritedTags.Length > 0)
-        {
-            var includeTags = filter.IncludeInheritedTags.Select(e => e.GetCleanValue()).ToArray();
-            baseQuery = baseQuery.Where(e =>
-                context.ItemValuesMap.Any(f =>
-                    f.ItemValue.Type == ItemValueType.Tags
-                    && includeTags.Contains(f.ItemValue.CleanValue)
-                    && (f.ItemId == e.Id
-                        || (e.SeriesId.HasValue && f.ItemId == e.SeriesId.Value)
-                        || e.Parents!.Any(p => f.ItemId == p.ParentItemId)
-                        || (e.TopParentId.HasValue && f.ItemId == e.TopParentId.Value))));
-        }
-
-        return baseQuery;
-    }
-
-    /// <inheritdoc/>
-    public IReadOnlyDictionary<string, MusicArtist[]> FindArtists(IReadOnlyList<string> artistNames)
-    {
-        using var dbContext = _dbProvider.CreateDbContext();
-
-        var artists = dbContext.BaseItems.Where(e => e.Type == _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]!)
-            .Where(e => artistNames.Contains(e.Name))
-            .ToArray();
-
-        var lookup = artists
-            .GroupBy(e => e.Name!)
-            .ToDictionary(
-                g => g.Key,
-                g => g.Select(f => DeserializeBaseItem(f)).Where(dto => dto is not null).Cast<MusicArtist>().ToArray());
-
-        var result = new Dictionary<string, MusicArtist[]>(artistNames.Count);
-        foreach (var name in artistNames)
-        {
-            if (lookup.TryGetValue(name, out var artistArray))
-            {
-                result[name] = artistArray;
-            }
-        }
-
-        return result;
-    }
-
-    /// <inheritdoc/>
-    public IReadOnlyList<Guid> GetManualLinkedParentIds(Guid childId)
-    {
-        using var context = _dbProvider.CreateDbContext();
-        return context.LinkedChildren
-            .Where(lc => lc.ChildId == childId && lc.ChildType == DbLinkedChildType.Manual)
-            .Select(lc => lc.ParentId)
-            .Distinct()
-            .ToList();
-    }
-
-    /// <inheritdoc/>
-    public IReadOnlyList<Guid> RerouteLinkedChildren(Guid fromChildId, Guid toChildId)
-    {
-        using var context = _dbProvider.CreateDbContext();
-
-        // Collect all affected parent IDs before modifying
-        var affectedParentIds = context.LinkedChildren
-            .Where(lc => lc.ChildId == fromChildId && lc.ChildType == DbLinkedChildType.Manual)
-            .Select(lc => lc.ParentId)
-            .Distinct()
-            .ToList();
-
-        if (affectedParentIds.Count == 0)
-        {
-            return affectedParentIds;
-        }
-
-        // Get parents that already reference toChildId (to avoid duplicates)
-        var parentsWithTarget = context.LinkedChildren
-            .Where(lc => lc.ChildId == toChildId && lc.ChildType == DbLinkedChildType.Manual)
-            .Select(lc => lc.ParentId)
-            .ToHashSet();
-
-        // Update references that won't create duplicates
-        context.LinkedChildren
-            .Where(lc => lc.ChildId == fromChildId
-                && lc.ChildType == DbLinkedChildType.Manual
-                && !parentsWithTarget.Contains(lc.ParentId))
-            .ExecuteUpdate(s => s.SetProperty(e => e.ChildId, toChildId));
-
-        // Remove references that would be duplicates
-        context.LinkedChildren
-            .Where(lc => lc.ChildId == fromChildId
-                && lc.ChildType == DbLinkedChildType.Manual
-                && parentsWithTarget.Contains(lc.ParentId))
-            .ExecuteDelete();
-
-        return affectedParentIds;
-    }
-
-    /// <inheritdoc/>
-    public void UpsertLinkedChild(Guid parentId, Guid childId, LinkedChildType childType)
-    {
-        using var context = _dbProvider.CreateDbContext();
-
-        var dbChildType = (DbLinkedChildType)childType;
-        var existingLink = context.LinkedChildren
-            .FirstOrDefault(lc => lc.ParentId == parentId && lc.ChildId == childId);
-
-        if (existingLink is null)
-        {
-            context.LinkedChildren.Add(new LinkedChildEntity
-            {
-                ParentId = parentId,
-                ChildId = childId,
-                ChildType = dbChildType,
-                SortOrder = null
-            });
-        }
-        else
-        {
-            existingLink.ChildType = dbChildType;
-        }
-
-        context.SaveChanges();
-    }
-
-    /// <summary>
-    /// Builds a filter expression for max parental rating that handles both rated items
-    /// and unrated BoxSets/Playlists (which check linked children's ratings).
-    /// </summary>
-    private static Expression<Func<BaseItemEntity, bool>> BuildMaxParentalRatingFilter(
-        JellyfinDbContext context,
-        ParentalRatingScore maxRating)
-    {
-        var maxScore = maxRating.Score;
-        var maxSubScore = maxRating.SubScore ?? 0;
-        var linkedChildren = context.LinkedChildren;
-
-        return e =>
-            // Item has a rating: check against limit
-            (e.InheritedParentalRatingValue != null
-                && (e.InheritedParentalRatingValue < maxScore
-                    || (e.InheritedParentalRatingValue == maxScore && (e.InheritedParentalRatingSubValue ?? 0) <= maxSubScore)))
-            // Item has no rating
-            || (e.InheritedParentalRatingValue == null
-                && (
-                    // No linked children (not a BoxSet/Playlist): pass as unrated
-                    !linkedChildren.Any(lc => lc.ParentId == e.Id)
-                    // Has linked children: at least one child must be within limits
-                    || linkedChildren.Any(lc => lc.ParentId == e.Id
-                        && (lc.Child!.InheritedParentalRatingValue == null
-                            || lc.Child.InheritedParentalRatingValue < maxScore
-                            || (lc.Child.InheritedParentalRatingValue == maxScore
-                                && (lc.Child.InheritedParentalRatingSubValue ?? 0) <= maxSubScore)))));
+        var typeToSerialise = BaseItemMapper.GetType(entity.Type);
+        return BaseItemMapper.DeserializeBaseItem(
+            entity,
+            _logger,
+            _appHost,
+            skipDeserialization || (_serverConfigurationManager.Configuration.SkipDeserializationForBasicTypes && (typeToSerialise == typeof(Channel) || typeToSerialise == typeof(UserRootFolder))));
     }
 }
diff --git a/Jellyfin.Server.Implementations/Item/ItemCountService.cs b/Jellyfin.Server.Implementations/Item/ItemCountService.cs
new file mode 100644
index 0000000000..604db9f839
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/ItemCountService.cs
@@ -0,0 +1,427 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Dto;
+using Microsoft.EntityFrameworkCore;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+/// <summary>
+/// Provides item counting and played-status query operations.
+/// </summary>
+public class ItemCountService : IItemCountService
+{
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IItemTypeLookup _itemTypeLookup;
+    private readonly IItemQueryHelpers _queryHelpers;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ItemCountService"/> class.
+    /// </summary>
+    /// <param name="dbProvider">The database context factory.</param>
+    /// <param name="itemTypeLookup">The item type lookup.</param>
+    /// <param name="queryHelpers">The shared query helpers.</param>
+    public ItemCountService(
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IItemTypeLookup itemTypeLookup,
+        IItemQueryHelpers queryHelpers)
+    {
+        _dbProvider = dbProvider;
+        _itemTypeLookup = itemTypeLookup;
+        _queryHelpers = queryHelpers;
+    }
+
+    /// <inheritdoc/>
+    public int GetCount(InternalItemsQuery filter)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        _queryHelpers.PrepareFilterQuery(filter);
+
+        using var context = _dbProvider.CreateDbContext();
+        var dbQuery = _queryHelpers.TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);
+
+        return dbQuery.Count();
+    }
+
+    /// <inheritdoc />
+    public ItemCounts GetItemCounts(InternalItemsQuery filter)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        _queryHelpers.PrepareFilterQuery(filter);
+
+        using var context = _dbProvider.CreateDbContext();
+        var dbQuery = _queryHelpers.TranslateQuery(context.BaseItems.AsNoTracking(), context, filter);
+
+        var counts = dbQuery
+            .GroupBy(x => x.Type)
+            .Select(x => new { x.Key, Count = x.Count() })
+            .ToArray();
+
+        var lookup = _itemTypeLookup.BaseItemKindNames;
+        var result = new ItemCounts
+        {
+            ItemCount = counts.Sum(c => c.Count)
+        };
+        foreach (var count in counts)
+        {
+            if (string.Equals(count.Key, lookup[BaseItemKind.MusicAlbum], StringComparison.Ordinal))
+            {
+                result.AlbumCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicArtist], StringComparison.Ordinal))
+            {
+                result.ArtistCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Episode], StringComparison.Ordinal))
+            {
+                result.EpisodeCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Movie], StringComparison.Ordinal))
+            {
+                result.MovieCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicVideo], StringComparison.Ordinal))
+            {
+                result.MusicVideoCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.LiveTvProgram], StringComparison.Ordinal))
+            {
+                result.ProgramCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Series], StringComparison.Ordinal))
+            {
+                result.SeriesCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Audio], StringComparison.Ordinal))
+            {
+                result.SongCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Trailer], StringComparison.Ordinal))
+            {
+                result.TrailerCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.BoxSet], StringComparison.Ordinal))
+            {
+                result.BoxSetCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Book], StringComparison.Ordinal))
+            {
+                result.BookCount = count.Count;
+            }
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc />
+    public ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, InternalItemsQuery accessFilter)
+    {
+        using var context = _dbProvider.CreateDbContext();
+
+        var item = context.BaseItems.AsNoTracking()
+            .Where(e => e.Id == id)
+            .Select(e => new { e.Name, e.CleanName })
+            .FirstOrDefault();
+
+        if (item is null)
+        {
+            return new ItemCounts();
+        }
+
+        IQueryable<BaseItemEntity> baseQuery;
+        switch (kind)
+        {
+            case BaseItemKind.Person:
+                baseQuery = context.PeopleBaseItemMap
+                    .AsNoTracking()
+                    .Where(m => m.People.Name == item.Name)
+                    .Select(m => m.Item);
+                break;
+            case BaseItemKind.MusicArtist:
+                baseQuery = context.ItemValuesMap
+                    .AsNoTracking()
+                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
+                        && (ivm.ItemValue.Type == ItemValueType.Artist || ivm.ItemValue.Type == ItemValueType.AlbumArtist))
+                    .Select(ivm => ivm.Item);
+                break;
+            case BaseItemKind.Genre:
+            case BaseItemKind.MusicGenre:
+                baseQuery = context.ItemValuesMap
+                    .AsNoTracking()
+                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
+                        && ivm.ItemValue.Type == ItemValueType.Genre)
+                    .Select(ivm => ivm.Item);
+                break;
+            case BaseItemKind.Studio:
+                baseQuery = context.ItemValuesMap
+                    .AsNoTracking()
+                    .Where(ivm => ivm.ItemValue.CleanValue == item.CleanName
+                        && ivm.ItemValue.Type == ItemValueType.Studios)
+                    .Select(ivm => ivm.Item);
+                break;
+            case BaseItemKind.Year:
+                if (int.TryParse(item.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var year))
+                {
+                    baseQuery = context.BaseItems
+                        .AsNoTracking()
+                        .Where(e => e.ProductionYear == year);
+                }
+                else
+                {
+                    return new ItemCounts();
+                }
+
+                break;
+            default:
+                return new ItemCounts();
+        }
+
+        var typeNames = relatedItemKinds.Select(k => _itemTypeLookup.BaseItemKindNames[k]).ToArray();
+        baseQuery = baseQuery.Where(e => typeNames.Contains(e.Type));
+
+        baseQuery = _queryHelpers.ApplyAccessFiltering(context, baseQuery, accessFilter);
+
+        var counts = baseQuery
+            .GroupBy(x => x.Type)
+            .Select(x => new { x.Key, Count = x.Count() })
+            .ToArray();
+
+        var lookup = _itemTypeLookup.BaseItemKindNames;
+        var result = new ItemCounts();
+        var totalCount = 0;
+
+        foreach (var count in counts)
+        {
+            totalCount += count.Count;
+
+            if (string.Equals(count.Key, lookup[BaseItemKind.MusicAlbum], StringComparison.Ordinal))
+            {
+                result.AlbumCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicArtist], StringComparison.Ordinal))
+            {
+                result.ArtistCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Episode], StringComparison.Ordinal))
+            {
+                result.EpisodeCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Movie], StringComparison.Ordinal))
+            {
+                result.MovieCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.MusicVideo], StringComparison.Ordinal))
+            {
+                result.MusicVideoCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.LiveTvProgram], StringComparison.Ordinal))
+            {
+                result.ProgramCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Series], StringComparison.Ordinal))
+            {
+                result.SeriesCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Audio], StringComparison.Ordinal))
+            {
+                result.SongCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Trailer], StringComparison.Ordinal))
+            {
+                result.TrailerCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.BoxSet], StringComparison.Ordinal))
+            {
+                result.BoxSetCount = count.Count;
+            }
+            else if (string.Equals(count.Key, lookup[BaseItemKind.Book], StringComparison.Ordinal))
+            {
+                result.BookCount = count.Count;
+            }
+        }
+
+        result.ItemCount = totalCount;
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public int GetPlayedCount(InternalItemsQuery filter, Guid ancestorId)
+    {
+        ArgumentNullException.ThrowIfNull(filter.User);
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        var baseQuery = _queryHelpers.BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
+        return baseQuery.Count(b => b.UserData!.Any(u => u.UserId == filter.User.Id && u.Played));
+    }
+
+    /// <inheritdoc/>
+    public int GetTotalCount(InternalItemsQuery filter, Guid ancestorId)
+    {
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        var baseQuery = _queryHelpers.BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
+        return baseQuery.Count();
+    }
+
+    /// <inheritdoc/>
+    public (int Played, int Total) GetPlayedAndTotalCount(InternalItemsQuery filter, Guid ancestorId)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        ArgumentNullException.ThrowIfNull(filter.User);
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        var baseQuery = _queryHelpers.BuildAccessFilteredDescendantsQuery(dbContext, filter, ancestorId);
+        return GetPlayedAndTotalCountFromQuery(baseQuery, filter.User.Id);
+    }
+
+    /// <inheritdoc/>
+    public (int Played, int Total) GetPlayedAndTotalCountFromLinkedChildren(InternalItemsQuery filter, Guid parentId)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        ArgumentNullException.ThrowIfNull(filter.User);
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        var allDescendantIds = DescendantQueryHelper.GetAllDescendantIds(dbContext, parentId);
+        var baseQuery = dbContext.BaseItems
+            .Where(b => allDescendantIds.Contains(b.Id) && !b.IsFolder && !b.IsVirtualItem);
+        baseQuery = _queryHelpers.ApplyAccessFiltering(dbContext, baseQuery, filter);
+
+        return GetPlayedAndTotalCountFromQuery(baseQuery, filter.User.Id);
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId)
+    {
+        ArgumentNullException.ThrowIfNull(parentIds);
+
+        if (parentIds.Count == 0)
+        {
+            return new Dictionary<Guid, int>();
+        }
+
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        var parentIdsArray = parentIds.ToArray();
+
+        var hierarchicalCounts = dbContext.BaseItems
+            .Where(b => b.ParentId.HasValue && parentIdsArray.Contains(b.ParentId.Value))
+            .GroupBy(b => b.ParentId!.Value)
+            .Select(g => new { ParentId = g.Key, Count = g.Count() })
+            .ToDictionary(x => x.ParentId, x => x.Count);
+
+        var linkedCounts = dbContext.LinkedChildren
+            .Where(lc => parentIdsArray.Contains(lc.ParentId))
+            .GroupBy(lc => lc.ParentId)
+            .Select(g => new { ParentId = g.Key, Count = g.Count() })
+            .ToDictionary(x => x.ParentId, x => x.Count);
+
+        var result = new Dictionary<Guid, int>();
+        foreach (var parentId in parentIds)
+        {
+            var hierarchicalCount = hierarchicalCounts.GetValueOrDefault(parentId, 0);
+            var linkedCount = linkedCounts.GetValueOrDefault(parentId, 0);
+
+            result[parentId] = linkedCount > 0 ? linkedCount : hierarchicalCount;
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user)
+    {
+        ArgumentNullException.ThrowIfNull(folderIds);
+        ArgumentNullException.ThrowIfNull(user);
+
+        if (folderIds.Count == 0)
+        {
+            return new Dictionary<Guid, (int Played, int Total)>();
+        }
+
+        using var dbContext = _dbProvider.CreateDbContext();
+        var folderIdsArray = folderIds.ToArray();
+        var filter = new InternalItemsQuery(user);
+        var userId = user.Id;
+
+        var leafItems = dbContext.BaseItems
+            .Where(b => !b.IsFolder && !b.IsVirtualItem);
+        leafItems = _queryHelpers.ApplyAccessFiltering(dbContext, leafItems, filter);
+
+        var playedLeafItems = leafItems
+            .Select(b => new { b.Id, Played = b.UserData!.Any(ud => ud.UserId == userId && ud.Played) });
+
+        var ancestorLeaves = dbContext.AncestorIds
+            .WhereOneOrMany(folderIdsArray, a => a.ParentItemId)
+            .Join(
+                playedLeafItems,
+                a => a.ItemId,
+                b => b.Id,
+                (a, b) => new { FolderId = a.ParentItemId, b.Id, b.Played });
+
+        var linkedLeaves = dbContext.LinkedChildren
+            .WhereOneOrMany(folderIdsArray, lc => lc.ParentId)
+            .Join(
+                playedLeafItems,
+                lc => lc.ChildId,
+                b => b.Id,
+                (lc, b) => new { FolderId = lc.ParentId, b.Id, b.Played });
+
+        var linkedFolderLeaves = dbContext.LinkedChildren
+            .WhereOneOrMany(folderIdsArray, lc => lc.ParentId)
+            .Join(
+                dbContext.BaseItems.Where(b => b.IsFolder),
+                lc => lc.ChildId,
+                b => b.Id,
+                (lc, b) => new { lc.ParentId, FolderChildId = b.Id })
+            .Join(
+                dbContext.AncestorIds,
+                x => x.FolderChildId,
+                a => a.ParentItemId,
+                (x, a) => new { x.ParentId, DescendantId = a.ItemId })
+            .Join(
+                playedLeafItems,
+                x => x.DescendantId,
+                b => b.Id,
+                (x, b) => new { FolderId = x.ParentId, b.Id, b.Played });
+
+        var results = ancestorLeaves
+            .Union(linkedLeaves)
+            .Union(linkedFolderLeaves)
+            .GroupBy(x => x.FolderId)
+            .Select(g => new
+            {
+                FolderId = g.Key,
+                Total = g.Select(x => x.Id).Distinct().Count(),
+                Played = g.Where(x => x.Played).Select(x => x.Id).Distinct().Count()
+            })
+            .ToDictionary(x => x.FolderId, x => (x.Played, x.Total));
+
+        return results;
+    }
+
+    private static (int Played, int Total) GetPlayedAndTotalCountFromQuery(IQueryable<BaseItemEntity> query, Guid userId)
+    {
+        var result = query
+            .Select(b => b.UserData!.Any(u => u.UserId == userId && u.Played))
+            .GroupBy(_ => 1)
+            .OrderBy(g => g.Key)
+            .Select(g => new
+            {
+                Total = g.Count(),
+                Played = g.Count(isPlayed => isPlayed)
+            })
+            .FirstOrDefault();
+
+        return result is null ? (0, 0) : (result.Played, result.Total);
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs b/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
new file mode 100644
index 0000000000..55839223a9
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
@@ -0,0 +1,637 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Controller.Playlists;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;
+using DbLinkedChildType = Jellyfin.Database.Implementations.Entities.LinkedChildType;
+using LinkedChildType = MediaBrowser.Controller.Entities.LinkedChildType;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+/// <summary>
+/// Handles item persistence operations (save, delete, update).
+/// </summary>
+public class ItemPersistenceService : IItemPersistenceService
+{
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IServerApplicationHost _appHost;
+    private readonly ILogger<ItemPersistenceService> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ItemPersistenceService"/> class.
+    /// </summary>
+    /// <param name="dbProvider">The database context factory.</param>
+    /// <param name="appHost">The application host.</param>
+    /// <param name="logger">The logger.</param>
+    public ItemPersistenceService(
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IServerApplicationHost appHost,
+        ILogger<ItemPersistenceService> logger)
+    {
+        _dbProvider = dbProvider;
+        _appHost = appHost;
+        _logger = logger;
+    }
+
+    /// <inheritdoc />
+    public void DeleteItem(params IReadOnlyList<Guid> ids)
+    {
+        if (ids is null || ids.Count == 0 || ids.Any(f => f.Equals(BaseItemRepository.PlaceholderId)))
+        {
+            throw new ArgumentException("Guid can't be empty or the placeholder id.", nameof(ids));
+        }
+
+        using var context = _dbProvider.CreateDbContext();
+        using var transaction = context.Database.BeginTransaction();
+
+        var date = (DateTime?)DateTime.UtcNow;
+
+        var descendantIds = DescendantQueryHelper.GetOwnedDescendantIdsBatch(context, ids);
+        foreach (var id in ids)
+        {
+            descendantIds.Add(id);
+        }
+
+        var extraIds = context.BaseItems
+            .Where(e => e.OwnerId.HasValue && descendantIds.Contains(e.OwnerId.Value))
+            .Select(e => e.Id)
+            .ToArray();
+
+        foreach (var extraId in extraIds)
+        {
+            descendantIds.Add(extraId);
+        }
+
+        var relatedItems = descendantIds.ToArray();
+
+        context.UserData
+            .Join(
+                context.UserData.WhereOneOrMany(relatedItems, e => e.ItemId),
+                placeholder => new { placeholder.UserId, placeholder.CustomDataKey },
+                userData => new { userData.UserId, userData.CustomDataKey },
+                (placeholder, userData) => placeholder)
+            .Where(e => e.ItemId == BaseItemRepository.PlaceholderId)
+            .ExecuteDelete();
+
+        context.UserData.WhereOneOrMany(relatedItems, e => e.ItemId)
+            .ExecuteUpdate(e => e
+                .SetProperty(f => f.RetentionDate, date)
+                .SetProperty(f => f.ItemId, BaseItemRepository.PlaceholderId));
+
+        context.AncestorIds.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.AncestorIds.WhereOneOrMany(relatedItems, e => e.ParentItemId).ExecuteDelete();
+        context.AttachmentStreamInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.BaseItemImageInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.BaseItemMetadataFields.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.BaseItemProviders.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.BaseItemTrailerTypes.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.Chapters.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.CustomItemDisplayPreferences.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.ItemDisplayPreferences.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.ItemValues.Where(e => e.BaseItemsMap!.Count == 0).ExecuteDelete();
+        context.ItemValuesMap.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.LinkedChildren.WhereOneOrMany(relatedItems, e => e.ParentId).ExecuteDelete();
+        context.LinkedChildren.WhereOneOrMany(relatedItems, e => e.ChildId).ExecuteDelete();
+        context.BaseItems.WhereOneOrMany(relatedItems, e => e.Id).ExecuteDelete();
+        context.KeyframeData.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.MediaSegments.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.MediaStreamInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        var query = context.PeopleBaseItemMap.WhereOneOrMany(relatedItems, e => e.ItemId).Select(f => f.PeopleId).Distinct().ToArray();
+        context.PeopleBaseItemMap.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.Peoples.WhereOneOrMany(query, e => e.Id).Where(e => e.BaseItems!.Count == 0).ExecuteDelete();
+        context.TrickplayInfos.WhereOneOrMany(relatedItems, e => e.ItemId).ExecuteDelete();
+        context.SaveChanges();
+        transaction.Commit();
+    }
+
+    /// <inheritdoc />
+    public void UpdateInheritedValues()
+    {
+        using var context = _dbProvider.CreateDbContext();
+        using var transaction = context.Database.BeginTransaction();
+
+        context.ItemValuesMap.Where(e => e.ItemValue.Type == ItemValueType.InheritedTags).ExecuteDelete();
+        context.SaveChanges();
+
+        transaction.Commit();
+    }
+
+    /// <inheritdoc />
+    public void SaveItems(IReadOnlyList<BaseItemDto> items, CancellationToken cancellationToken)
+    {
+        UpdateOrInsertItems(items, cancellationToken);
+    }
+
+    /// <inheritdoc />
+    public async Task SaveImagesAsync(BaseItem item, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+
+        var images = item.ImageInfos.Select(e => BaseItemMapper.MapImageToEntity(item.Id, e)).ToArray();
+
+        var context = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        await using (context.ConfigureAwait(false))
+        {
+            if (!await context.BaseItems
+                .AnyAsync(bi => bi.Id == item.Id, cancellationToken)
+                .ConfigureAwait(false))
+            {
+                _logger.LogWarning("Unable to save ImageInfo for non existing BaseItem");
+                return;
+            }
+
+            await context.BaseItemImageInfos
+                .Where(e => e.ItemId == item.Id)
+                .ExecuteDeleteAsync(cancellationToken)
+                .ConfigureAwait(false);
+
+            await context.BaseItemImageInfos
+                .AddRangeAsync(images, cancellationToken)
+                .ConfigureAwait(false);
+
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+        }
+    }
+
+    /// <inheritdoc />
+    public async Task ReattachUserDataAsync(BaseItemDto item, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var dbContext = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+
+        await using (dbContext.ConfigureAwait(false))
+        {
+            var transaction = await dbContext.Database.BeginTransactionAsync(cancellationToken).ConfigureAwait(false);
+            await using (transaction.ConfigureAwait(false))
+            {
+                var userKeys = item.GetUserDataKeys().ToArray();
+                var retentionDate = (DateTime?)null;
+
+                await dbContext.UserData
+                    .Where(e => e.ItemId == BaseItemRepository.PlaceholderId)
+                    .Where(e => userKeys.Contains(e.CustomDataKey))
+                    .ExecuteUpdateAsync(
+                        e => e
+                            .SetProperty(f => f.ItemId, item.Id)
+                            .SetProperty(f => f.RetentionDate, retentionDate),
+                        cancellationToken).ConfigureAwait(false);
+
+                item.UserData = await dbContext.UserData
+                    .AsNoTracking()
+                    .Where(e => e.ItemId == item.Id)
+                    .ToArrayAsync(cancellationToken)
+                    .ConfigureAwait(false);
+
+                await transaction.CommitAsync(cancellationToken).ConfigureAwait(false);
+            }
+        }
+    }
+
+    private void UpdateOrInsertItems(IReadOnlyList<BaseItemDto> items, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(items);
+        cancellationToken.ThrowIfCancellationRequested();
+
+        var tuples = new List<(BaseItemDto Item, List<Guid>? AncestorIds, BaseItemDto TopParent, IEnumerable<string> UserDataKey, List<string> InheritedTags)>();
+        foreach (var item in items.GroupBy(e => e.Id).Select(e => e.Last()).Where(e => e.Id != BaseItemRepository.PlaceholderId))
+        {
+            var ancestorIds = item.SupportsAncestors ?
+                item.GetAncestorIds().Distinct().ToList() :
+                null;
+
+            var topParent = item.GetTopParent();
+
+            var userdataKey = item.GetUserDataKeys();
+            var inheritedTags = item.GetInheritedTags();
+
+            tuples.Add((item, ancestorIds, topParent, userdataKey, inheritedTags));
+        }
+
+        using var context = _dbProvider.CreateDbContext();
+        using var transaction = context.Database.BeginTransaction();
+
+        var ids = tuples.Select(f => f.Item.Id).ToArray();
+        var existingItems = context.BaseItems.Where(e => ids.Contains(e.Id)).Select(f => f.Id).ToArray();
+
+        foreach (var item in tuples)
+        {
+            var entity = BaseItemMapper.Map(item.Item, _appHost);
+            entity.TopParentId = item.TopParent?.Id;
+
+            if (!existingItems.Any(e => e == entity.Id))
+            {
+                context.BaseItems.Add(entity);
+            }
+            else
+            {
+                context.BaseItemProviders.Where(e => e.ItemId == entity.Id).ExecuteDelete();
+                context.BaseItemImageInfos.Where(e => e.ItemId == entity.Id).ExecuteDelete();
+                context.BaseItemMetadataFields.Where(e => e.ItemId == entity.Id).ExecuteDelete();
+
+                if (entity.Images is { Count: > 0 })
+                {
+                    context.BaseItemImageInfos.AddRange(entity.Images);
+                }
+
+                if (entity.LockedFields is { Count: > 0 })
+                {
+                    context.BaseItemMetadataFields.AddRange(entity.LockedFields);
+                }
+
+                context.BaseItems.Attach(entity).State = EntityState.Modified;
+            }
+        }
+
+        var itemValueMaps = tuples
+            .Select(e => (e.Item, Values: GetItemValuesToSave(e.Item, e.InheritedTags)))
+            .ToArray();
+        var allListedItemValues = itemValueMaps
+            .SelectMany(f => f.Values)
+            .Distinct()
+            .ToArray();
+        var existingValues = context.ItemValues
+            .Select(e => new
+            {
+                item = e,
+                Key = e.Type + "+" + e.Value
+            })
+            .Where(f => allListedItemValues.Select(e => $"{(int)e.MagicNumber}+{e.Value}").Contains(f.Key))
+            .Select(e => e.item)
+            .ToArray();
+        var missingItemValues = allListedItemValues.Except(existingValues.Select(f => (MagicNumber: f.Type, f.Value))).Select(f => new ItemValue()
+        {
+            CleanValue = f.Value.GetCleanValue(),
+            ItemValueId = Guid.NewGuid(),
+            Type = f.MagicNumber,
+            Value = f.Value
+        }).ToArray();
+        context.ItemValues.AddRange(missingItemValues);
+
+        var itemValuesStore = existingValues.Concat(missingItemValues).ToArray();
+        var valueMap = itemValueMaps
+            .Select(f => (f.Item, Values: f.Values.Select(e => itemValuesStore.First(g => g.Value == e.Value && g.Type == e.MagicNumber)).DistinctBy(e => e.ItemValueId).ToArray()))
+            .ToArray();
+
+        var mappedValues = context.ItemValuesMap.Where(e => ids.Contains(e.ItemId)).ToList();
+
+        foreach (var item in valueMap)
+        {
+            var itemMappedValues = mappedValues.Where(e => e.ItemId == item.Item.Id).ToList();
+            foreach (var itemValue in item.Values)
+            {
+                var existingItem = itemMappedValues.FirstOrDefault(f => f.ItemValueId == itemValue.ItemValueId);
+                if (existingItem is null)
+                {
+                    context.ItemValuesMap.Add(new ItemValueMap()
+                    {
+                        Item = null!,
+                        ItemId = item.Item.Id,
+                        ItemValue = null!,
+                        ItemValueId = itemValue.ItemValueId
+                    });
+                }
+                else
+                {
+                    itemMappedValues.Remove(existingItem);
+                }
+            }
+
+            context.ItemValuesMap.RemoveRange(itemMappedValues);
+        }
+
+        var itemsWithAncestors = tuples
+            .Where(t => t.Item.SupportsAncestors && t.AncestorIds != null)
+            .Select(t => t.Item.Id)
+            .ToList();
+
+        var allExistingAncestorIds = itemsWithAncestors.Count > 0
+            ? context.AncestorIds
+                .Where(e => itemsWithAncestors.Contains(e.ItemId))
+                .ToList()
+                .GroupBy(e => e.ItemId)
+                .ToDictionary(g => g.Key, g => g.ToList())
+            : new Dictionary<Guid, List<AncestorId>>();
+
+        var allRequestedAncestorIds = tuples
+            .Where(t => t.Item.SupportsAncestors && t.AncestorIds != null)
+            .SelectMany(t => t.AncestorIds!)
+            .Distinct()
+            .ToList();
+
+        var validAncestorIdsSet = allRequestedAncestorIds.Count > 0
+            ? context.BaseItems
+                .Where(e => allRequestedAncestorIds.Contains(e.Id))
+                .Select(f => f.Id)
+                .ToHashSet()
+            : new HashSet<Guid>();
+
+        foreach (var item in tuples)
+        {
+            if (item.Item.SupportsAncestors && item.AncestorIds != null)
+            {
+                var existingAncestorIds = allExistingAncestorIds.GetValueOrDefault(item.Item.Id) ?? new List<AncestorId>();
+                var validAncestorIds = item.AncestorIds.Where(id => validAncestorIdsSet.Contains(id)).ToArray();
+                foreach (var ancestorId in validAncestorIds)
+                {
+                    var existingAncestorId = existingAncestorIds.FirstOrDefault(e => e.ParentItemId == ancestorId);
+                    if (existingAncestorId is null)
+                    {
+                        context.AncestorIds.Add(new AncestorId()
+                        {
+                            ParentItemId = ancestorId,
+                            ItemId = item.Item.Id,
+                            Item = null!,
+                            ParentItem = null!
+                        });
+                    }
+                    else
+                    {
+                        existingAncestorIds.Remove(existingAncestorId);
+                    }
+                }
+
+                context.AncestorIds.RemoveRange(existingAncestorIds);
+            }
+        }
+
+        context.SaveChanges();
+
+        var folderIds = tuples
+            .Where(t => t.Item is Folder)
+            .Select(t => t.Item.Id)
+            .ToList();
+
+        var videoIds = tuples
+            .Where(t => t.Item is Video)
+            .Select(t => t.Item.Id)
+            .ToList();
+
+        var allLinkedChildrenByParent = new Dictionary<Guid, List<LinkedChildEntity>>();
+        if (folderIds.Count > 0 || videoIds.Count > 0)
+        {
+            var allParentIds = folderIds.Concat(videoIds).Distinct().ToList();
+            var allLinkedChildren = context.LinkedChildren
+                .Where(e => allParentIds.Contains(e.ParentId))
+                .ToList();
+
+            allLinkedChildrenByParent = allLinkedChildren
+                .GroupBy(e => e.ParentId)
+                .ToDictionary(g => g.Key, g => g.ToList());
+        }
+
+        foreach (var item in tuples)
+        {
+            if (item.Item is Folder folder)
+            {
+                var existingLinkedChildren = allLinkedChildrenByParent.GetValueOrDefault(item.Item.Id)?.ToList() ?? new List<LinkedChildEntity>();
+                if (folder.LinkedChildren.Length > 0)
+                {
+#pragma warning disable CS0618 // Type or member is obsolete - legacy path resolution for old data
+                    var pathsToResolve = folder.LinkedChildren
+                        .Where(lc => (!lc.ItemId.HasValue || lc.ItemId.Value.IsEmpty()) && !string.IsNullOrEmpty(lc.Path))
+                        .Select(lc => lc.Path)
+                        .Distinct()
+                        .ToList();
+
+                    var pathToIdMap = pathsToResolve.Count > 0
+                        ? context.BaseItems
+                            .Where(e => e.Path != null && pathsToResolve.Contains(e.Path))
+                            .Select(e => new { e.Path, e.Id })
+                            .GroupBy(e => e.Path!)
+                            .ToDictionary(g => g.Key, g => g.First().Id)
+                        : [];
+
+                    var resolvedChildren = new List<(LinkedChild Child, Guid ChildId)>();
+                    foreach (var linkedChild in folder.LinkedChildren)
+                    {
+                        var childItemId = linkedChild.ItemId;
+                        if (!childItemId.HasValue || childItemId.Value.IsEmpty())
+                        {
+                            if (!string.IsNullOrEmpty(linkedChild.Path) && pathToIdMap.TryGetValue(linkedChild.Path, out var resolvedId))
+                            {
+                                childItemId = resolvedId;
+                            }
+                        }
+#pragma warning restore CS0618
+
+                        if (childItemId.HasValue && !childItemId.Value.IsEmpty())
+                        {
+                            resolvedChildren.Add((linkedChild, childItemId.Value));
+                        }
+                    }
+
+                    resolvedChildren = resolvedChildren
+                        .GroupBy(c => c.ChildId)
+                        .Select(g => g.Last())
+                        .ToList();
+
+                    var childIdsToCheck = resolvedChildren.Select(c => c.ChildId).ToList();
+                    var existingChildIds = childIdsToCheck.Count > 0
+                        ? context.BaseItems
+                            .Where(e => childIdsToCheck.Contains(e.Id))
+                            .Select(e => e.Id)
+                            .ToHashSet()
+                        : [];
+
+                    var isPlaylist = folder is Playlist;
+                    var sortOrder = 0;
+                    foreach (var (linkedChild, childId) in resolvedChildren)
+                    {
+                        if (!existingChildIds.Contains(childId))
+                        {
+                            _logger.LogWarning(
+                                "Skipping LinkedChild for parent {ParentName} ({ParentId}): child item {ChildId} does not exist in database",
+                                item.Item.Name,
+                                item.Item.Id,
+                                childId);
+                            continue;
+                        }
+
+                        var existingLink = existingLinkedChildren.FirstOrDefault(e => e.ChildId == childId);
+                        if (existingLink is null)
+                        {
+                            context.LinkedChildren.Add(new LinkedChildEntity()
+                            {
+                                ParentId = item.Item.Id,
+                                ChildId = childId,
+                                ChildType = (DbLinkedChildType)linkedChild.Type,
+                                SortOrder = isPlaylist ? sortOrder : null
+                            });
+                        }
+                        else
+                        {
+                            existingLink.SortOrder = isPlaylist ? sortOrder : null;
+                            existingLink.ChildType = (DbLinkedChildType)linkedChild.Type;
+                            existingLinkedChildren.Remove(existingLink);
+                        }
+
+                        sortOrder++;
+                    }
+                }
+
+                if (existingLinkedChildren.Count > 0)
+                {
+                    context.LinkedChildren.RemoveRange(existingLinkedChildren);
+                }
+            }
+
+            if (item.Item is Video video)
+            {
+                var existingLinkedChildren = (allLinkedChildrenByParent.GetValueOrDefault(video.Id) ?? new List<LinkedChildEntity>())
+                    .Where(e => (int)e.ChildType == 2 || (int)e.ChildType == 3)
+                    .ToList();
+
+                var newLinkedChildren = new List<(Guid ChildId, LinkedChildType Type)>();
+
+                if (video.LocalAlternateVersions.Length > 0)
+                {
+                    var pathsToResolve = video.LocalAlternateVersions.Where(p => !string.IsNullOrEmpty(p)).ToList();
+                    if (pathsToResolve.Count > 0)
+                    {
+                        var pathToIdMap = context.BaseItems
+                            .Where(e => e.Path != null && pathsToResolve.Contains(e.Path))
+                            .Select(e => new { e.Path, e.Id })
+                            .GroupBy(e => e.Path!)
+                            .ToDictionary(g => g.Key, g => g.First().Id);
+
+                        foreach (var path in pathsToResolve)
+                        {
+                            if (pathToIdMap.TryGetValue(path, out var childId))
+                            {
+                                newLinkedChildren.Add((childId, LinkedChildType.LocalAlternateVersion));
+                            }
+                        }
+                    }
+                }
+
+                if (video.LinkedAlternateVersions.Length > 0)
+                {
+                    foreach (var linkedChild in video.LinkedAlternateVersions)
+                    {
+                        if (linkedChild.ItemId.HasValue && !linkedChild.ItemId.Value.IsEmpty())
+                        {
+                            newLinkedChildren.Add((linkedChild.ItemId.Value, LinkedChildType.LinkedAlternateVersion));
+                        }
+                    }
+                }
+
+                newLinkedChildren = newLinkedChildren
+                    .GroupBy(c => c.ChildId)
+                    .Select(g => g.Last())
+                    .ToList();
+
+                var childIdsToCheck = newLinkedChildren.Select(c => c.ChildId).ToList();
+                var existingChildIds = childIdsToCheck.Count > 0
+                    ? context.BaseItems
+                        .Where(e => childIdsToCheck.Contains(e.Id))
+                        .Select(e => e.Id)
+                        .ToHashSet()
+                    : [];
+
+                int sortOrder = 0;
+                foreach (var (childId, childType) in newLinkedChildren)
+                {
+                    if (!existingChildIds.Contains(childId))
+                    {
+                        _logger.LogWarning(
+                            "Skipping alternate version for video {VideoName} ({VideoId}): child item {ChildId} does not exist in database",
+                            video.Name,
+                            video.Id,
+                            childId);
+                        continue;
+                    }
+
+                    var existingLink = existingLinkedChildren.FirstOrDefault(e => e.ChildId == childId);
+                    if (existingLink is null)
+                    {
+                        context.LinkedChildren.Add(new LinkedChildEntity
+                        {
+                            ParentId = video.Id,
+                            ChildId = childId,
+                            ChildType = (DbLinkedChildType)childType,
+                            SortOrder = sortOrder
+                        });
+                    }
+                    else
+                    {
+                        existingLink.ChildType = (DbLinkedChildType)childType;
+                        existingLink.SortOrder = sortOrder;
+                        existingLinkedChildren.Remove(existingLink);
+                    }
+
+                    sortOrder++;
+                }
+
+                if (existingLinkedChildren.Count > 0)
+                {
+                    var orphanedLocalVersionIds = existingLinkedChildren
+                        .Where(e => e.ChildType == DbLinkedChildType.LocalAlternateVersion)
+                        .Select(e => e.ChildId)
+                        .ToList();
+
+                    context.LinkedChildren.RemoveRange(existingLinkedChildren);
+
+                    if (orphanedLocalVersionIds.Count > 0)
+                    {
+                        var orphanedItems = context.BaseItems
+                            .Where(e => orphanedLocalVersionIds.Contains(e.Id) && e.OwnerId == video.Id)
+                            .ToList();
+
+                        if (orphanedItems.Count > 0)
+                        {
+                            _logger.LogInformation(
+                                "Deleting {Count} orphaned LocalAlternateVersion items for video {VideoName} ({VideoId})",
+                                orphanedItems.Count,
+                                video.Name,
+                                video.Id);
+                            context.BaseItems.RemoveRange(orphanedItems);
+                        }
+                    }
+                }
+            }
+        }
+
+        context.SaveChanges();
+        transaction.Commit();
+    }
+
+    private static List<(ItemValueType MagicNumber, string Value)> GetItemValuesToSave(BaseItemDto item, List<string> inheritedTags)
+    {
+        var list = new List<(ItemValueType, string)>();
+
+        if (item is IHasArtist hasArtist)
+        {
+            list.AddRange(hasArtist.Artists.Select(i => ((ItemValueType)0, i)));
+        }
+
+        if (item is IHasAlbumArtist hasAlbumArtist)
+        {
+            list.AddRange(hasAlbumArtist.AlbumArtists.Select(i => (ItemValueType.AlbumArtist, i)));
+        }
+
+        list.AddRange(item.Genres.Select(i => (ItemValueType.Genre, i)));
+        list.AddRange(item.Studios.Select(i => (ItemValueType.Studios, i)));
+        list.AddRange(item.Tags.Select(i => (ItemValueType.Tags, i)));
+
+        list.AddRange(inheritedTags.Select(i => (ItemValueType.InheritedTags, i)));
+
+        list.RemoveAll(i => string.IsNullOrWhiteSpace(i.Item2));
+
+        return list;
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs b/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
new file mode 100644
index 0000000000..19afe04f01
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
@@ -0,0 +1,160 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.EntityFrameworkCore;
+using DbLinkedChildType = Jellyfin.Database.Implementations.Entities.LinkedChildType;
+using LinkedChildType = MediaBrowser.Controller.Entities.LinkedChildType;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+/// <summary>
+/// Provides linked children query and manipulation operations.
+/// </summary>
+public class LinkedChildrenService : ILinkedChildrenService
+{
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IItemTypeLookup _itemTypeLookup;
+    private readonly IItemQueryHelpers _queryHelpers;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LinkedChildrenService"/> class.
+    /// </summary>
+    /// <param name="dbProvider">The database context factory.</param>
+    /// <param name="itemTypeLookup">The item type lookup.</param>
+    /// <param name="queryHelpers">The shared query helpers.</param>
+    public LinkedChildrenService(
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IItemTypeLookup itemTypeLookup,
+        IItemQueryHelpers queryHelpers)
+    {
+        _dbProvider = dbProvider;
+        _itemTypeLookup = itemTypeLookup;
+        _queryHelpers = queryHelpers;
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<Guid> GetLinkedChildrenIds(Guid parentId, int? childType = null)
+    {
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        var query = dbContext.LinkedChildren
+            .Where(lc => lc.ParentId.Equals(parentId));
+
+        if (childType.HasValue)
+        {
+            query = query.Where(lc => (int)lc.ChildType == childType.Value);
+        }
+
+        return query
+            .OrderBy(lc => lc.SortOrder)
+            .Select(lc => lc.ChildId)
+            .ToList();
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyDictionary<string, MusicArtist[]> FindArtists(IReadOnlyList<string> artistNames)
+    {
+        using var dbContext = _dbProvider.CreateDbContext();
+
+        var artists = dbContext.BaseItems.Where(e => e.Type == _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist]!)
+            .Where(e => artistNames.Contains(e.Name))
+            .ToArray();
+
+        var lookup = artists
+            .GroupBy(e => e.Name!)
+            .ToDictionary(
+                g => g.Key,
+                g => g.Select(f => _queryHelpers.DeserializeBaseItem(f)).Where(dto => dto is not null).Cast<MusicArtist>().ToArray());
+
+        var result = new Dictionary<string, MusicArtist[]>(artistNames.Count);
+        foreach (var name in artistNames)
+        {
+            if (lookup.TryGetValue(name, out var artistArray))
+            {
+                result[name] = artistArray;
+            }
+        }
+
+        return result;
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<Guid> GetManualLinkedParentIds(Guid childId)
+    {
+        using var context = _dbProvider.CreateDbContext();
+        return context.LinkedChildren
+            .Where(lc => lc.ChildId == childId && lc.ChildType == DbLinkedChildType.Manual)
+            .Select(lc => lc.ParentId)
+            .Distinct()
+            .ToList();
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<Guid> RerouteLinkedChildren(Guid fromChildId, Guid toChildId)
+    {
+        using var context = _dbProvider.CreateDbContext();
+
+        var affectedParentIds = context.LinkedChildren
+            .Where(lc => lc.ChildId == fromChildId && lc.ChildType == DbLinkedChildType.Manual)
+            .Select(lc => lc.ParentId)
+            .Distinct()
+            .ToList();
+
+        if (affectedParentIds.Count == 0)
+        {
+            return affectedParentIds;
+        }
+
+        var parentsWithTarget = context.LinkedChildren
+            .Where(lc => lc.ChildId == toChildId && lc.ChildType == DbLinkedChildType.Manual)
+            .Select(lc => lc.ParentId)
+            .ToHashSet();
+
+        context.LinkedChildren
+            .Where(lc => lc.ChildId == fromChildId
+                && lc.ChildType == DbLinkedChildType.Manual
+                && !parentsWithTarget.Contains(lc.ParentId))
+            .ExecuteUpdate(s => s.SetProperty(e => e.ChildId, toChildId));
+
+        context.LinkedChildren
+            .Where(lc => lc.ChildId == fromChildId
+                && lc.ChildType == DbLinkedChildType.Manual
+                && parentsWithTarget.Contains(lc.ParentId))
+            .ExecuteDelete();
+
+        return affectedParentIds;
+    }
+
+    /// <inheritdoc/>
+    public void UpsertLinkedChild(Guid parentId, Guid childId, LinkedChildType childType)
+    {
+        using var context = _dbProvider.CreateDbContext();
+
+        var dbChildType = (DbLinkedChildType)childType;
+        var existingLink = context.LinkedChildren
+            .FirstOrDefault(lc => lc.ParentId == parentId && lc.ChildId == childId);
+
+        if (existingLink is null)
+        {
+            context.LinkedChildren.Add(new Jellyfin.Database.Implementations.Entities.LinkedChildEntity
+            {
+                ParentId = parentId,
+                ChildId = childId,
+                ChildType = dbChildType,
+                SortOrder = null
+            });
+        }
+        else
+        {
+            existingLink.ChildType = dbChildType;
+        }
+
+        context.SaveChanges();
+    }
+}
diff --git a/Jellyfin.Server.Implementations/Item/NextUpService.cs b/Jellyfin.Server.Implementations/Item/NextUpService.cs
new file mode 100644
index 0000000000..1f5616bb5e
--- /dev/null
+++ b/Jellyfin.Server.Implementations/Item/NextUpService.cs
@@ -0,0 +1,345 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Persistence;
+using Microsoft.EntityFrameworkCore;
+using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;
+
+namespace Jellyfin.Server.Implementations.Item;
+
+/// <summary>
+/// Provides next-up episode query operations.
+/// </summary>
+public class NextUpService : INextUpService
+{
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IItemTypeLookup _itemTypeLookup;
+    private readonly IItemQueryHelpers _queryHelpers;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="NextUpService"/> class.
+    /// </summary>
+    /// <param name="dbProvider">The database context factory.</param>
+    /// <param name="itemTypeLookup">The item type lookup.</param>
+    /// <param name="queryHelpers">The shared query helpers.</param>
+    public NextUpService(
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IItemTypeLookup itemTypeLookup,
+        IItemQueryHelpers queryHelpers)
+    {
+        _dbProvider = dbProvider;
+        _itemTypeLookup = itemTypeLookup;
+        _queryHelpers = queryHelpers;
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyList<string> GetNextUpSeriesKeys(InternalItemsQuery filter, DateTime dateCutoff)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        ArgumentNullException.ThrowIfNull(filter.User);
+
+        using var context = _dbProvider.CreateDbContext();
+
+        var query = context.BaseItems
+            .AsNoTracking()
+            .Where(i => filter.TopParentIds.Contains(i.TopParentId!.Value))
+            .Where(i => i.Type == _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode])
+            .Join(
+                context.UserData.AsNoTracking().Where(e => e.ItemId != EF.Constant(BaseItemRepository.PlaceholderId)),
+                i => new { UserId = filter.User.Id, ItemId = i.Id },
+                u => new { u.UserId, u.ItemId },
+                (entity, data) => new { Item = entity, UserData = data })
+            .GroupBy(g => g.Item.SeriesPresentationUniqueKey)
+            .Select(g => new { g.Key, LastPlayedDate = g.Max(u => u.UserData.LastPlayedDate) })
+            .Where(g => g.Key != null && g.LastPlayedDate != null && g.LastPlayedDate >= dateCutoff)
+            .OrderByDescending(g => g.LastPlayedDate)
+            .Select(g => g.Key!);
+
+        if (filter.Limit.HasValue)
+        {
+            query = query.Take(filter.Limit.Value);
+        }
+
+        return query.ToArray();
+    }
+
+    /// <inheritdoc />
+    public IReadOnlyDictionary<string, NextUpEpisodeBatchResult> GetNextUpEpisodesBatch(
+        InternalItemsQuery filter,
+        IReadOnlyList<string> seriesKeys,
+        bool includeSpecials,
+        bool includeWatchedForRewatching)
+    {
+        ArgumentNullException.ThrowIfNull(filter);
+        ArgumentNullException.ThrowIfNull(filter.User);
+
+        if (seriesKeys.Count == 0)
+        {
+            return new Dictionary<string, NextUpEpisodeBatchResult>();
+        }
+
+        _queryHelpers.PrepareFilterQuery(filter);
+        using var context = _dbProvider.CreateDbContext();
+
+        var userId = filter.User.Id;
+        var episodeTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Episode];
+
+        var lastWatchedBase = context.BaseItems
+            .AsNoTracking()
+            .Where(e => e.Type == episodeTypeName)
+            .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
+            .Where(e => e.ParentIndexNumber != 0)
+            .Where(e => e.UserData!.Any(ud => ud.UserId == userId && ud.Played));
+        lastWatchedBase = _queryHelpers.ApplyAccessFiltering(context, lastWatchedBase, filter);
+        var lastWatchedInfo = lastWatchedBase
+            .GroupBy(e => e.SeriesPresentationUniqueKey)
+            .Select(g => new
+            {
+                SeriesKey = g.Key!,
+                LastWatchedId = g.OrderByDescending(e => e.ParentIndexNumber)
+                                 .ThenByDescending(e => e.IndexNumber)
+                                 .Select(e => e.Id)
+                                 .FirstOrDefault()
+            })
+            .ToDictionary(x => x.SeriesKey, x => x.LastWatchedId);
+
+        Dictionary<string, Guid> lastWatchedByDateInfo = new();
+        if (includeWatchedForRewatching)
+        {
+            var lastWatchedByDateBase = context.BaseItems
+                .AsNoTracking()
+                .Where(e => e.Type == episodeTypeName)
+                .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
+                .Where(e => e.ParentIndexNumber != 0)
+                .Where(e => e.UserData!.Any(ud => ud.UserId == userId && ud.Played));
+            lastWatchedByDateBase = _queryHelpers.ApplyAccessFiltering(context, lastWatchedByDateBase, filter);
+            lastWatchedByDateInfo = lastWatchedByDateBase
+                .SelectMany(e => e.UserData!.Where(ud => ud.UserId == userId && ud.Played)
+                    .Select(ud => new { Episode = e, ud.LastPlayedDate }))
+                .GroupBy(x => x.Episode.SeriesPresentationUniqueKey)
+                .Select(g => new
+                {
+                    SeriesKey = g.Key!,
+                    LastWatchedId = g.OrderByDescending(x => x.LastPlayedDate)
+                                     .Select(x => x.Episode.Id)
+                                     .FirstOrDefault()
+                })
+                .ToDictionary(x => x.SeriesKey, x => x.LastWatchedId);
+        }
+
+        var allLastWatchedIds = lastWatchedInfo.Values
+            .Concat(lastWatchedByDateInfo.Values)
+            .Where(id => id != Guid.Empty)
+            .Distinct()
+            .ToList();
+        var lastWatchedEpisodes = new Dictionary<Guid, BaseItemEntity>();
+        if (allLastWatchedIds.Count > 0)
+        {
+            var lwQuery = context.BaseItems.AsNoTracking().Where(e => allLastWatchedIds.Contains(e.Id));
+            lwQuery = _queryHelpers.ApplyNavigations(lwQuery, filter);
+            lastWatchedEpisodes = lwQuery.ToDictionary(e => e.Id);
+        }
+
+        Dictionary<string, List<BaseItemEntity>> specialsBySeriesKey = new();
+        if (includeSpecials)
+        {
+            var specialsQuery = context.BaseItems
+                .AsNoTracking()
+                .Where(e => e.Type == episodeTypeName)
+                .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
+                .Where(e => e.ParentIndexNumber == 0)
+                .Where(e => !e.IsVirtualItem);
+            specialsQuery = _queryHelpers.ApplyAccessFiltering(context, specialsQuery, filter);
+            specialsQuery = _queryHelpers.ApplyNavigations(specialsQuery, filter).AsSingleQuery();
+
+            foreach (var special in specialsQuery)
+            {
+                var key = special.SeriesPresentationUniqueKey!;
+                if (!specialsBySeriesKey.TryGetValue(key, out var list))
+                {
+                    list = new List<BaseItemEntity>();
+                    specialsBySeriesKey[key] = list;
+                }
+
+                list.Add(special);
+            }
+        }
+
+        var positionLookup = new Dictionary<string, (int Season, int Episode)>();
+        foreach (var kvp in lastWatchedInfo)
+        {
+            if (kvp.Value != Guid.Empty
+                && lastWatchedEpisodes.TryGetValue(kvp.Value, out var lw)
+                && lw.ParentIndexNumber.HasValue
+                && lw.IndexNumber.HasValue)
+            {
+                positionLookup[kvp.Key] = (lw.ParentIndexNumber.Value, lw.IndexNumber.Value);
+            }
+        }
+
+        var allUnplayedBase = context.BaseItems
+            .AsNoTracking()
+            .Where(e => e.Type == episodeTypeName)
+            .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
+            .Where(e => e.ParentIndexNumber != 0)
+            .Where(e => !e.IsVirtualItem)
+            .Where(e => !e.UserData!.Any(ud => ud.UserId == userId && ud.Played));
+        allUnplayedBase = _queryHelpers.ApplyAccessFiltering(context, allUnplayedBase, filter);
+        var allUnplayedCandidates = allUnplayedBase
+            .Select(e => new
+            {
+                e.Id,
+                e.SeriesPresentationUniqueKey,
+                e.ParentIndexNumber,
+                EpisodeNumber = e.IndexNumber
+            })
+            .ToList();
+
+        var nextEpisodeIds = new HashSet<Guid>();
+        var seriesNextIdMap = new Dictionary<string, Guid>();
+
+        foreach (var seriesKey in seriesKeys)
+        {
+            var candidates = allUnplayedCandidates
+                .Where(c => c.SeriesPresentationUniqueKey == seriesKey);
+
+            if (positionLookup.TryGetValue(seriesKey, out var pos))
+            {
+                candidates = candidates.Where(c =>
+                    c.ParentIndexNumber > pos.Season
+                    || (c.ParentIndexNumber == pos.Season && c.EpisodeNumber > pos.Episode));
+            }
+
+            var nextCandidate = candidates
+                .OrderBy(c => c.ParentIndexNumber)
+                .ThenBy(c => c.EpisodeNumber)
+                .FirstOrDefault();
+
+            if (nextCandidate is not null && nextCandidate.Id != Guid.Empty)
+            {
+                nextEpisodeIds.Add(nextCandidate.Id);
+                seriesNextIdMap[seriesKey] = nextCandidate.Id;
+            }
+        }
+
+        var seriesNextPlayedIdMap = new Dictionary<string, Guid>();
+        if (includeWatchedForRewatching)
+        {
+            var allPlayedBase = context.BaseItems
+                .AsNoTracking()
+                .Where(e => e.Type == episodeTypeName)
+                .Where(e => e.SeriesPresentationUniqueKey != null && seriesKeys.Contains(e.SeriesPresentationUniqueKey))
+                .Where(e => e.ParentIndexNumber != 0)
+                .Where(e => !e.IsVirtualItem)
+                .Where(e => e.UserData!.Any(ud => ud.UserId == userId && ud.Played));
+            allPlayedBase = _queryHelpers.ApplyAccessFiltering(context, allPlayedBase, filter);
+            var allPlayedCandidates = allPlayedBase
+                .Select(e => new
+                {
+                    e.Id,
+                    e.SeriesPresentationUniqueKey,
+                    e.ParentIndexNumber,
+                    EpisodeNumber = e.IndexNumber
+                })
+                .ToList();
+
+            foreach (var seriesKey in seriesKeys)
+            {
+                if (!lastWatchedByDateInfo.TryGetValue(seriesKey, out var lastByDateId))
+                {
+                    continue;
+                }
+
+                var lastByDateEntity = lastWatchedEpisodes.GetValueOrDefault(lastByDateId);
+                if (lastByDateEntity is null)
+                {
+                    continue;
+                }
+
+                var playedCandidates = allPlayedCandidates
+                    .Where(c => c.SeriesPresentationUniqueKey == seriesKey);
+
+                if (lastByDateEntity.ParentIndexNumber.HasValue && lastByDateEntity.IndexNumber.HasValue)
+                {
+                    var lastSeason = lastByDateEntity.ParentIndexNumber.Value;
+                    var lastEp = lastByDateEntity.IndexNumber.Value;
+                    playedCandidates = playedCandidates.Where(c =>
+                        c.ParentIndexNumber > lastSeason
+                        || (c.ParentIndexNumber == lastSeason && c.EpisodeNumber > lastEp));
+                }
+
+                var nextPlayedCandidate = playedCandidates
+                    .OrderBy(c => c.ParentIndexNumber)
+                    .ThenBy(c => c.EpisodeNumber)
+                    .FirstOrDefault();
+
+                if (nextPlayedCandidate is not null && nextPlayedCandidate.Id != Guid.Empty)
+                {
+                    nextEpisodeIds.Add(nextPlayedCandidate.Id);
+                    seriesNextPlayedIdMap[seriesKey] = nextPlayedCandidate.Id;
+                }
+            }
+        }
+
+        var nextEpisodes = new Dictionary<Guid, BaseItemEntity>();
+        if (nextEpisodeIds.Count > 0)
+        {
+            var nextQuery = context.BaseItems.AsNoTracking().Where(e => nextEpisodeIds.Contains(e.Id));
+            nextQuery = _queryHelpers.ApplyNavigations(nextQuery, filter).AsSingleQuery();
+            nextEpisodes = nextQuery.ToDictionary(e => e.Id);
+        }
+
+        var result = new Dictionary<string, NextUpEpisodeBatchResult>();
+        foreach (var seriesKey in seriesKeys)
+        {
+            var batchResult = new NextUpEpisodeBatchResult();
+
+            if (lastWatchedInfo.TryGetValue(seriesKey, out var lwId) && lwId != Guid.Empty)
+            {
+                if (lastWatchedEpisodes.TryGetValue(lwId, out var entity))
+                {
+                    batchResult.LastWatched = _queryHelpers.DeserializeBaseItem(entity, filter.SkipDeserialization);
+                }
+            }
+
+            if (seriesNextIdMap.TryGetValue(seriesKey, out var nextId) && nextEpisodes.TryGetValue(nextId, out var nextEntity))
+            {
+                batchResult.NextUp = _queryHelpers.DeserializeBaseItem(nextEntity, filter.SkipDeserialization);
+            }
+
+            if (includeSpecials && specialsBySeriesKey.TryGetValue(seriesKey, out var specials))
+            {
+                batchResult.Specials = specials.Select(s => _queryHelpers.DeserializeBaseItem(s, filter.SkipDeserialization)!).ToList();
+            }
+            else
+            {
+                batchResult.Specials = Array.Empty<BaseItemDto>();
+            }
+
+            if (includeWatchedForRewatching)
+            {
+                if (lastWatchedByDateInfo.TryGetValue(seriesKey, out var lastByDateId) &&
+                    lastWatchedEpisodes.TryGetValue(lastByDateId, out var lastByDateEntity))
+                {
+                    batchResult.LastWatchedForRewatching = _queryHelpers.DeserializeBaseItem(lastByDateEntity, filter.SkipDeserialization);
+                }
+
+                if (seriesNextPlayedIdMap.TryGetValue(seriesKey, out var nextPlayedId) &&
+                    nextEpisodes.TryGetValue(nextPlayedId, out var nextPlayedEntity))
+                {
+                    batchResult.NextPlayedForRewatching = _queryHelpers.DeserializeBaseItem(nextPlayedEntity, filter.SkipDeserialization);
+                }
+            }
+
+            result[seriesKey] = batchResult;
+        }
+
+        return result;
+    }
+}
diff --git a/Jellyfin.Server/Migrations/Routines/CleanupOrphanedExtras.cs b/Jellyfin.Server/Migrations/Routines/CleanupOrphanedExtras.cs
index ffde30f0ca..fccecfa9dc 100644
--- a/Jellyfin.Server/Migrations/Routines/CleanupOrphanedExtras.cs
+++ b/Jellyfin.Server/Migrations/Routines/CleanupOrphanedExtras.cs
@@ -36,6 +36,7 @@ public class CleanupOrphanedExtras : IAsyncMigrationRoutine
     /// <param name="dbContextFactory">The database context factory.</param>
     /// <param name="libraryManager">The library manager.</param>
     /// <param name="itemRepository">The item repository.</param>
+    /// <param name="itemCountService">The item count service.</param>
     /// <param name="channelManager">The channel manager.</param>
     /// <param name="recordingsManager">The recordings manager.</param>
     /// <param name="mediaSourceManager">The media source manager.</param>
@@ -46,6 +47,7 @@ public class CleanupOrphanedExtras : IAsyncMigrationRoutine
         IDbContextFactory<JellyfinDbContext> dbContextFactory,
         ILibraryManager libraryManager,
         IItemRepository itemRepository,
+        IItemCountService itemCountService,
         IChannelManager channelManager,
         IRecordingsManager recordingsManager,
         IMediaSourceManager mediaSourceManager,
@@ -57,6 +59,7 @@ public class CleanupOrphanedExtras : IAsyncMigrationRoutine
         _libraryManager = libraryManager;
         BaseItem.LibraryManager ??= libraryManager;
         BaseItem.ItemRepository ??= itemRepository;
+        BaseItem.ItemCountService ??= itemCountService;
         BaseItem.ChannelManager ??= channelManager;
         BaseItem.MediaSourceManager ??= mediaSourceManager;
         BaseItem.MediaSegmentManager ??= mediaSegmentManager;
diff --git a/Jellyfin.Server/Migrations/Routines/FixAudioData.cs b/Jellyfin.Server/Migrations/Routines/FixAudioData.cs
index 05ded06ba8..d102e24b91 100644
--- a/Jellyfin.Server/Migrations/Routines/FixAudioData.cs
+++ b/Jellyfin.Server/Migrations/Routines/FixAudioData.cs
@@ -1,10 +1,6 @@
-using System;
-using System.Globalization;
-using System.IO;
 using System.Linq;
 using System.Threading;
 using Jellyfin.Data.Enums;
-using MediaBrowser.Controller;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Controller.Persistence;
@@ -23,16 +19,19 @@ namespace Jellyfin.Server.Migrations.Routines
 #pragma warning restore CS0618 // Type or member is obsolete
     {
         private readonly ILogger<FixAudioData> _logger;
-        private readonly IServerApplicationPaths _applicationPaths;
         private readonly IItemRepository _itemRepository;
+        private readonly IItemCountService _countService;
+        private readonly IItemPersistenceService _persistenceService;
 
         public FixAudioData(
-            IServerApplicationPaths applicationPaths,
             ILoggerFactory loggerFactory,
-            IItemRepository itemRepository)
+            IItemRepository itemRepository,
+            IItemCountService countService,
+            IItemPersistenceService persistenceService)
         {
-            _applicationPaths = applicationPaths;
             _itemRepository = itemRepository;
+            _countService = countService;
+            _persistenceService = persistenceService;
             _logger = loggerFactory.CreateLogger<FixAudioData>();
         }
 
@@ -41,7 +40,7 @@ namespace Jellyfin.Server.Migrations.Routines
         {
             _logger.LogInformation("Backfilling audio lyrics data to database.");
             var startIndex = 0;
-            var records = _itemRepository.GetCount(new InternalItemsQuery
+            var records = _countService.GetCount(new InternalItemsQuery
             {
                 IncludeItemTypes = [BaseItemKind.Audio],
             });
@@ -68,7 +67,7 @@ namespace Jellyfin.Server.Migrations.Routines
                     }
                 }
 
-                _itemRepository.SaveItems(results, CancellationToken.None);
+                _persistenceService.SaveItems(results, CancellationToken.None);
                 startIndex += results.Count;
                 _logger.LogInformation("Backfilled data for {UpdatedRecords} of {TotalRecords} audio records", startIndex, records);
             }
diff --git a/Jellyfin.Server/Migrations/Routines/FixIncorrectOwnerIdRelationships.cs b/Jellyfin.Server/Migrations/Routines/FixIncorrectOwnerIdRelationships.cs
index b9f5964c6a..c926362802 100644
--- a/Jellyfin.Server/Migrations/Routines/FixIncorrectOwnerIdRelationships.cs
+++ b/Jellyfin.Server/Migrations/Routines/FixIncorrectOwnerIdRelationships.cs
@@ -24,7 +24,7 @@ public class FixIncorrectOwnerIdRelationships : IAsyncMigrationRoutine
     private readonly IStartupLogger<FixIncorrectOwnerIdRelationships> _logger;
     private readonly IDbContextFactory<JellyfinDbContext> _dbContextFactory;
     private readonly ILibraryManager _libraryManager;
-    private readonly IItemRepository _itemRepository;
+    private readonly IItemPersistenceService _persistenceService;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="FixIncorrectOwnerIdRelationships"/> class.
@@ -32,17 +32,17 @@ public class FixIncorrectOwnerIdRelationships : IAsyncMigrationRoutine
     /// <param name="logger">The startup logger.</param>
     /// <param name="dbContextFactory">The database context factory.</param>
     /// <param name="libraryManager">The library manager.</param>
-    /// <param name="itemRepository">The item repository.</param>
+    /// <param name="persistenceService">The item persistence service.</param>
     public FixIncorrectOwnerIdRelationships(
         IStartupLogger<FixIncorrectOwnerIdRelationships> logger,
         IDbContextFactory<JellyfinDbContext> dbContextFactory,
         ILibraryManager libraryManager,
-        IItemRepository itemRepository)
+        IItemPersistenceService persistenceService)
     {
         _logger = logger;
         _dbContextFactory = dbContextFactory;
         _libraryManager = libraryManager;
-        _itemRepository = itemRepository;
+        _persistenceService = persistenceService;
     }
 
     /// <inheritdoc/>
@@ -157,7 +157,7 @@ public class FixIncorrectOwnerIdRelationships : IAsyncMigrationRoutine
                     {
                         try
                         {
-                            _itemRepository.DeleteItem([itemId]);
+                            _persistenceService.DeleteItem([itemId]);
                             deletedCount++;
                             _logger.LogInformation("Successfully deleted duplicate item {ItemId} at path {Path} via direct database deletion", itemId, path);
                         }
diff --git a/MediaBrowser.Controller/Entities/BaseItem.cs b/MediaBrowser.Controller/Entities/BaseItem.cs
index e19074d0c9..94592eb24d 100644
--- a/MediaBrowser.Controller/Entities/BaseItem.cs
+++ b/MediaBrowser.Controller/Entities/BaseItem.cs
@@ -489,6 +489,8 @@ namespace MediaBrowser.Controller.Entities
 
         public static IItemRepository ItemRepository { get; set; }
 
+        public static IItemCountService ItemCountService { get; set; }
+
         public static IChapterManager ChapterManager { get; set; }
 
         public static IFileSystem FileSystem { get; set; }
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index 4506bafced..fbb18afa9e 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -1883,11 +1883,11 @@ namespace MediaBrowser.Controller.Entities
 
                     if (LinkedChildren.Length > 0)
                     {
-                        (playedCount, totalCount) = ItemRepository.GetPlayedAndTotalCountFromLinkedChildren(query, Id);
+                        (playedCount, totalCount) = ItemCountService.GetPlayedAndTotalCountFromLinkedChildren(query, Id);
                     }
                     else
                     {
-                        (playedCount, totalCount) = ItemRepository.GetPlayedAndTotalCount(query, Id);
+                        (playedCount, totalCount) = ItemCountService.GetPlayedAndTotalCount(query, Id);
                     }
                 }
 
diff --git a/MediaBrowser.Controller/Persistence/IItemCountService.cs b/MediaBrowser.Controller/Persistence/IItemCountService.cs
new file mode 100644
index 0000000000..d57f1fc893
--- /dev/null
+++ b/MediaBrowser.Controller/Persistence/IItemCountService.cs
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Dto;
+
+namespace MediaBrowser.Controller.Persistence;
+
+/// <summary>
+/// Provides item counting and played-status query operations.
+/// </summary>
+public interface IItemCountService
+{
+    /// <summary>
+    /// Gets the count of items matching the filter.
+    /// </summary>
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The item count.</returns>
+    int GetCount(InternalItemsQuery filter);
+
+    /// <summary>
+    /// Gets item counts grouped by type.
+    /// </summary>
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The item counts by type.</returns>
+    ItemCounts GetItemCounts(InternalItemsQuery filter);
+
+    /// <summary>
+    /// Gets item counts for a "by-name" item using an optimized query.
+    /// </summary>
+    /// <param name="kind">The kind of the name item.</param>
+    /// <param name="id">The ID of the name item.</param>
+    /// <param name="relatedItemKinds">The item kinds to count.</param>
+    /// <param name="accessFilter">A pre-configured query with user access filtering settings.</param>
+    /// <returns>The item counts grouped by type.</returns>
+    ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, InternalItemsQuery accessFilter);
+
+    /// <summary>
+    /// Gets the count of played items that are descendants of the specified ancestor.
+    /// </summary>
+    /// <param name="filter">The query filter containing user access settings.</param>
+    /// <param name="ancestorId">The ancestor item id.</param>
+    /// <returns>The count of played descendant items.</returns>
+    int GetPlayedCount(InternalItemsQuery filter, Guid ancestorId);
+
+    /// <summary>
+    /// Gets the total count of items that are descendants of the specified ancestor.
+    /// </summary>
+    /// <param name="filter">The query filter containing user access settings.</param>
+    /// <param name="ancestorId">The ancestor item id.</param>
+    /// <returns>The total count of descendant items.</returns>
+    int GetTotalCount(InternalItemsQuery filter, Guid ancestorId);
+
+    /// <summary>
+    /// Gets both the played count and total count of descendant items.
+    /// </summary>
+    /// <param name="filter">The query filter containing user access settings.</param>
+    /// <param name="ancestorId">The ancestor item id.</param>
+    /// <returns>A tuple containing (Played count, Total count).</returns>
+    (int Played, int Total) GetPlayedAndTotalCount(InternalItemsQuery filter, Guid ancestorId);
+
+    /// <summary>
+    /// Gets both the played count and total count from linked children.
+    /// </summary>
+    /// <param name="filter">The query filter containing user access settings.</param>
+    /// <param name="parentId">The parent item id.</param>
+    /// <returns>A tuple containing (Played count, Total count).</returns>
+    (int Played, int Total) GetPlayedAndTotalCountFromLinkedChildren(InternalItemsQuery filter, Guid parentId);
+
+    /// <summary>
+    /// Batch-fetches played and total counts for multiple folder items.
+    /// </summary>
+    /// <param name="folderIds">The list of folder item IDs to get counts for.</param>
+    /// <param name="user">The user for access filtering and played status.</param>
+    /// <returns>Dictionary mapping folder ID to (Played count, Total count).</returns>
+    Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user);
+
+    /// <summary>
+    /// Batch-fetches child counts for multiple parent folders.
+    /// </summary>
+    /// <param name="parentIds">The list of parent folder IDs.</param>
+    /// <param name="userId">The user ID for access filtering.</param>
+    /// <returns>Dictionary mapping parent ID to child count.</returns>
+    Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId);
+}
diff --git a/MediaBrowser.Controller/Persistence/IItemPersistenceService.cs b/MediaBrowser.Controller/Persistence/IItemPersistenceService.cs
new file mode 100644
index 0000000000..37f7194e7a
--- /dev/null
+++ b/MediaBrowser.Controller/Persistence/IItemPersistenceService.cs
@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Persistence;
+
+/// <summary>
+/// Provides item persistence operations (save, delete, update).
+/// </summary>
+public interface IItemPersistenceService
+{
+    /// <summary>
+    /// Deletes items by their IDs.
+    /// </summary>
+    /// <param name="ids">The IDs to delete.</param>
+    void DeleteItem(params IReadOnlyList<Guid> ids);
+
+    /// <summary>
+    /// Saves items to the database.
+    /// </summary>
+    /// <param name="items">The items to save.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    void SaveItems(IReadOnlyList<BaseItem> items, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Saves image info for an item.
+    /// </summary>
+    /// <param name="item">The item.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    Task SaveImagesAsync(BaseItem item, CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Reattaches user data entries to the correct item.
+    /// </summary>
+    /// <param name="item">The item.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>A task representing the asynchronous operation.</returns>
+    Task ReattachUserDataAsync(BaseItem item, CancellationToken cancellationToken);
+
+    /// <summary>
+    /// Updates inherited values.
+    /// </summary>
+    void UpdateInheritedValues();
+}
diff --git a/MediaBrowser.Controller/Persistence/IItemQueryHelpers.cs b/MediaBrowser.Controller/Persistence/IItemQueryHelpers.cs
new file mode 100644
index 0000000000..45fa92c90b
--- /dev/null
+++ b/MediaBrowser.Controller/Persistence/IItemQueryHelpers.cs
@@ -0,0 +1,94 @@
+using System;
+using System.Linq;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Persistence;
+
+/// <summary>
+/// Provides shared query-building methods used by extracted item services.
+/// Implemented by <c>BaseItemRepository</c>.
+/// </summary>
+public interface IItemQueryHelpers
+{
+    /// <summary>
+    /// Translates an <see cref="InternalItemsQuery"/> into EF Core filter expressions.
+    /// </summary>
+    /// <param name="baseQuery">The base queryable to filter.</param>
+    /// <param name="context">The database context.</param>
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The filtered queryable.</returns>
+    IQueryable<BaseItemEntity> TranslateQuery(
+        IQueryable<BaseItemEntity> baseQuery,
+        JellyfinDbContext context,
+        InternalItemsQuery filter);
+
+    /// <summary>
+    /// Prepares a base query for items from the context.
+    /// </summary>
+    /// <param name="context">The database context.</param>
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The prepared queryable.</returns>
+    IQueryable<BaseItemEntity> PrepareItemQuery(JellyfinDbContext context, InternalItemsQuery filter);
+
+    /// <summary>
+    /// Applies user access filtering (library access, parental controls, tags) to a query.
+    /// </summary>
+    /// <param name="context">The database context.</param>
+    /// <param name="baseQuery">The base queryable to filter.</param>
+    /// <param name="filter">The query filter containing access settings.</param>
+    /// <returns>The access-filtered queryable.</returns>
+    IQueryable<BaseItemEntity> ApplyAccessFiltering(
+        JellyfinDbContext context,
+        IQueryable<BaseItemEntity> baseQuery,
+        InternalItemsQuery filter);
+
+    /// <summary>
+    /// Applies navigation property includes to a query based on filter options.
+    /// </summary>
+    /// <param name="dbQuery">The queryable to apply navigations to.</param>
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The queryable with navigation includes.</returns>
+    IQueryable<BaseItemEntity> ApplyNavigations(
+        IQueryable<BaseItemEntity> dbQuery,
+        InternalItemsQuery filter);
+
+    /// <summary>
+    /// Applies ordering to a query based on filter options.
+    /// </summary>
+    /// <param name="query">The queryable to order.</param>
+    /// <param name="filter">The query filter.</param>
+    /// <param name="context">The database context.</param>
+    /// <returns>The ordered queryable.</returns>
+    IQueryable<BaseItemEntity> ApplyOrder(
+        IQueryable<BaseItemEntity> query,
+        InternalItemsQuery filter,
+        JellyfinDbContext context);
+
+    /// <summary>
+    /// Builds a query for descendants of an ancestor with user access filtering applied.
+    /// </summary>
+    /// <param name="context">The database context.</param>
+    /// <param name="filter">The query filter.</param>
+    /// <param name="ancestorId">The ancestor item ID.</param>
+    /// <returns>The filtered descendant queryable.</returns>
+    IQueryable<BaseItemEntity> BuildAccessFilteredDescendantsQuery(
+        JellyfinDbContext context,
+        InternalItemsQuery filter,
+        Guid ancestorId);
+
+    /// <summary>
+    /// Deserializes a <see cref="BaseItemEntity"/> into a <see cref="BaseItem"/>.
+    /// </summary>
+    /// <param name="entity">The database entity.</param>
+    /// <param name="skipDeserialization">Whether to skip JSON deserialization.</param>
+    /// <returns>The deserialized item, or null.</returns>
+    BaseItem? DeserializeBaseItem(BaseItemEntity entity, bool skipDeserialization = false);
+
+    /// <summary>
+    /// Prepares a filter query by adjusting limits and virtual item settings.
+    /// </summary>
+    /// <param name="query">The query to prepare.</param>
+    void PrepareFilterQuery(InternalItemsQuery query);
+}
diff --git a/MediaBrowser.Controller/Persistence/IItemRepository.cs b/MediaBrowser.Controller/Persistence/IItemRepository.cs
index 52250b4058..291916ab25 100644
--- a/MediaBrowser.Controller/Persistence/IItemRepository.cs
+++ b/MediaBrowser.Controller/Persistence/IItemRepository.cs
@@ -1,18 +1,13 @@
 #nullable disable
 
-#pragma warning disable CS1591
-
 using System;
 using System.Collections.Generic;
-using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Querying;
-using LinkedChildType = MediaBrowser.Controller.Entities.LinkedChildType;
 
 namespace MediaBrowser.Controller.Persistence;
 
@@ -21,29 +16,6 @@ namespace MediaBrowser.Controller.Persistence;
 /// </summary>
 public interface IItemRepository
 {
-    /// <summary>
-    /// Deletes the item.
-    /// </summary>
-    /// <param name="ids">The identifier to delete.</param>
-    void DeleteItem(params IReadOnlyList<Guid> ids);
-
-    /// <summary>
-    /// Saves the items.
-    /// </summary>
-    /// <param name="items">The items.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    void SaveItems(IReadOnlyList<BaseItem> items, CancellationToken cancellationToken);
-
-    Task SaveImagesAsync(BaseItem item, CancellationToken cancellationToken = default);
-
-    /// <summary>
-    /// Reattaches the user data to the item.
-    /// </summary>
-    /// <param name="item">The item.</param>
-    /// <param name="cancellationToken">The cancellation token.</param>
-    /// <returns>A task that represents the asynchronous reattachment operation.</returns>
-    Task ReattachUserDataAsync(BaseItem item, CancellationToken cancellationToken);
-
     /// <summary>
     /// Retrieves the item.
     /// </summary>
@@ -80,69 +52,6 @@ public interface IItemRepository
     /// <returns>List&lt;BaseItem&gt;.</returns>
     IReadOnlyList<BaseItem> GetLatestItemList(InternalItemsQuery filter, CollectionType collectionType);
 
-    /// <summary>
-    /// Gets the list of series presentation keys for next up.
-    /// </summary>
-    /// <param name="filter">The query.</param>
-    /// <param name="dateCutoff">The minimum date for a series to have been most recently watched.</param>
-    /// <returns>The list of keys.</returns>
-    IReadOnlyList<string> GetNextUpSeriesKeys(InternalItemsQuery filter, DateTime dateCutoff);
-
-    /// <summary>
-    /// Gets next up episodes for multiple series in a single batched query.
-    /// Returns the last watched episode, next unwatched episode, specials, and next played episode for each series.
-    /// </summary>
-    /// <param name="filter">The query filter.</param>
-    /// <param name="seriesKeys">The series presentation unique keys to query.</param>
-    /// <param name="includeSpecials">Whether to include specials (ParentIndexNumber = 0) in the results.</param>
-    /// <param name="includeWatchedForRewatching">Whether to include watched episodes for rewatching mode.</param>
-    /// <returns>A dictionary mapping series key to batch result containing episodes needed for NextUp calculation.</returns>
-    IReadOnlyDictionary<string, NextUpEpisodeBatchResult> GetNextUpEpisodesBatch(
-        InternalItemsQuery filter,
-        IReadOnlyList<string> seriesKeys,
-        bool includeSpecials,
-        bool includeWatchedForRewatching);
-
-    /// <summary>
-    /// Updates the inherited values.
-    /// </summary>
-    void UpdateInheritedValues();
-
-    int GetCount(InternalItemsQuery filter);
-
-    ItemCounts GetItemCounts(InternalItemsQuery filter);
-
-    /// <summary>
-    /// Gets item counts for a "by-name" item (Person, MusicArtist, Genre, MusicGenre, Studio, Year)
-    /// using an optimized query that starts from the mapping table instead of scanning all BaseItems.
-    /// </summary>
-    /// <param name="kind">The kind of the name item.</param>
-    /// <param name="id">The ID of the name item.</param>
-    /// <param name="relatedItemKinds">The item kinds to count.</param>
-    /// <param name="accessFilter">A pre-configured query with user access filtering settings.</param>
-    /// <returns>The item counts grouped by type.</returns>
-    ItemCounts GetItemCountsForNameItem(BaseItemKind kind, Guid id, BaseItemKind[] relatedItemKinds, InternalItemsQuery accessFilter);
-
-    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetGenres(InternalItemsQuery filter);
-
-    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetMusicGenres(InternalItemsQuery filter);
-
-    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetStudios(InternalItemsQuery filter);
-
-    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetArtists(InternalItemsQuery filter);
-
-    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetAlbumArtists(InternalItemsQuery filter);
-
-    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetAllArtists(InternalItemsQuery filter);
-
-    IReadOnlyList<string> GetMusicGenreNames();
-
-    IReadOnlyList<string> GetStudioNames();
-
-    IReadOnlyList<string> GetGenreNames();
-
-    IReadOnlyList<string> GetAllArtistNames();
-
     /// <summary>
     /// Checks if an item has been persisted to the database.
     /// </summary>
@@ -151,118 +60,84 @@ public interface IItemRepository
     Task<bool> ItemExistsAsync(Guid id);
 
     /// <summary>
-    /// Gets a value indicating wherever all children of the requested Id has been played.
+    /// Gets genres with item counts.
     /// </summary>
-    /// <param name="user">The userdata to check against.</param>
-    /// <param name="id">The Top id to check.</param>
-    /// <param name="recursive">Whever the check should be done recursive. Warning expensive operation.</param>
-    /// <returns>A value indicating whever all children has been played.</returns>
-    bool GetIsPlayed(User user, Guid id, bool recursive);
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The genres and their item counts.</returns>
+    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetGenres(InternalItemsQuery filter);
 
     /// <summary>
-    /// Gets the count of played items that are descendants of the specified ancestor.
-    /// Uses the AncestorIds table for efficient recursive lookup.
-    /// Applies user access filtering (library access, parental controls, tags).
+    /// Gets music genres with item counts.
     /// </summary>
-    /// <param name="filter">The query filter containing user access settings.</param>
-    /// <param name="ancestorId">The ancestor item id.</param>
-    /// <returns>The count of played descendant items.</returns>
-    int GetPlayedCount(InternalItemsQuery filter, Guid ancestorId);
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The music genres and their item counts.</returns>
+    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetMusicGenres(InternalItemsQuery filter);
 
     /// <summary>
-    /// Gets the total count of items that are descendants of the specified ancestor.
-    /// Uses the AncestorIds table for efficient recursive lookup.
-    /// Applies user access filtering (library access, parental controls, tags).
+    /// Gets studios with item counts.
     /// </summary>
-    /// <param name="filter">The query filter containing user access settings.</param>
-    /// <param name="ancestorId">The ancestor item id.</param>
-    /// <returns>The total count of descendant items.</returns>
-    int GetTotalCount(InternalItemsQuery filter, Guid ancestorId);
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The studios and their item counts.</returns>
+    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetStudios(InternalItemsQuery filter);
 
     /// <summary>
-    /// Gets both the played count and total count of items that are descendants of the specified ancestor.
-    /// Uses the AncestorIds table for efficient recursive lookup.
-    /// Applies user access filtering (library access, parental controls, tags).
+    /// Gets artists with item counts.
     /// </summary>
-    /// <param name="filter">The query filter containing user access settings.</param>
-    /// <param name="ancestorId">The ancestor item id.</param>
-    /// <returns>A tuple containing (Played count, Total count).</returns>
-    (int Played, int Total) GetPlayedAndTotalCount(InternalItemsQuery filter, Guid ancestorId);
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The artists and their item counts.</returns>
+    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetArtists(InternalItemsQuery filter);
 
     /// <summary>
-    /// Gets both the played count and total count of items that are linked children of the specified parent.
-    /// Uses the LinkedChildren table for BoxSets, Playlists, etc.
-    /// Applies user access filtering (library access, parental controls, tags).
+    /// Gets album artists with item counts.
     /// </summary>
-    /// <param name="filter">The query filter containing user access settings.</param>
-    /// <param name="parentId">The parent item id (BoxSet, Playlist, etc.).</param>
-    /// <returns>A tuple containing (Played count, Total count).</returns>
-    (int Played, int Total) GetPlayedAndTotalCountFromLinkedChildren(InternalItemsQuery filter, Guid parentId);
+    /// <param name="filter">The query filter.</param>
+    /// <returns>The album artists and their item counts.</returns>
+    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetAlbumArtists(InternalItemsQuery filter);
 
     /// <summary>
-    /// Batch-fetches played and total counts for multiple folder items using the AncestorIds table.
-    /// This avoids N+1 queries when building DTOs for lists of folder items (Series, Seasons, etc.).
-    /// Applies user access filtering (parental controls, tags).
+    /// Gets all artists with item counts.
     /// </summary>
-    /// <param name="folderIds">The list of folder item IDs to get counts for.</param>
-    /// <param name="user">The user for access filtering and played status.</param>
-    /// <returns>Dictionary mapping folder ID to (Played count, Total count).</returns>
-    Dictionary<Guid, (int Played, int Total)> GetPlayedAndTotalCountBatch(IReadOnlyList<Guid> folderIds, User user);
+    /// <param name="filter">The query filter.</param>
+    /// <returns>All artists and their item counts.</returns>
+    QueryResult<(BaseItem Item, ItemCounts ItemCounts)> GetAllArtists(InternalItemsQuery filter);
 
     /// <summary>
-    /// Gets the IDs of linked children for the specified parent.
+    /// Gets all music genre names.
     /// </summary>
-    /// <param name="parentId">The parent item ID.</param>
-    /// <param name="childType">Optional child type filter (e.g., LocalAlternateVersion, LinkedAlternateVersion).</param>
-    /// <returns>List of child item IDs.</returns>
-    IReadOnlyList<Guid> GetLinkedChildrenIds(Guid parentId, int? childType = null);
+    /// <returns>The list of music genre names.</returns>
+    IReadOnlyList<string> GetMusicGenreNames();
 
     /// <summary>
-    /// Gets all artist matches from the db.
+    /// Gets all studio names.
     /// </summary>
-    /// <param name="artistNames">The names of the artists.</param>
-    /// <returns>A map of the artist name and the potential matches.</returns>
-    IReadOnlyDictionary<string, MusicArtist[]> FindArtists(IReadOnlyList<string> artistNames);
+    /// <returns>The list of studio names.</returns>
+    IReadOnlyList<string> GetStudioNames();
 
     /// <summary>
-    /// Batch-fetches child counts for multiple parent folders.
-    /// Returns the count of immediate children (non-recursive) for each parent.
+    /// Gets all genre names.
     /// </summary>
-    /// <param name="parentIds">The list of parent folder IDs.</param>
-    /// <param name="userId">The user ID for access filtering.</param>
-    /// <returns>Dictionary mapping parent ID to child count.</returns>
-    Dictionary<Guid, int> GetChildCountBatch(IReadOnlyList<Guid> parentIds, Guid? userId);
+    /// <returns>The list of genre names.</returns>
+    IReadOnlyList<string> GetGenreNames();
 
     /// <summary>
-    /// Gets parent IDs (Playlists/BoxSets) that reference the specified child with LinkedChildType.Manual.
+    /// Gets all artist names.
     /// </summary>
-    /// <param name="childId">The child item ID.</param>
-    /// <returns>List of parent IDs that reference the child.</returns>
-    IReadOnlyList<Guid> GetManualLinkedParentIds(Guid childId);
+    /// <returns>The list of artist names.</returns>
+    IReadOnlyList<string> GetAllArtistNames();
 
     /// <summary>
-    /// Gets legacy query filters (Years, Genres, Tags, OfficialRatings) aggregated directly from the database.
+    /// Gets legacy query filters aggregated from the database.
     /// </summary>
     /// <param name="filter">The query filter.</param>
     /// <returns>Aggregated filter values.</returns>
     QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery filter);
 
     /// <summary>
-    /// Updates LinkedChildren references from one child to another, preserving SortOrder.
-    /// Handles duplicates: if parent already references toChildId, removes the old reference instead.
-    /// Used when video versions change to maintain collection integrity.
+    /// Gets whether all children of the requested item have been played.
     /// </summary>
-    /// <param name="fromChildId">The child ID to re-route from.</param>
-    /// <param name="toChildId">The child ID to re-route to.</param>
-    /// <returns>List of parent item IDs whose LinkedChildren were modified.</returns>
-    IReadOnlyList<Guid> RerouteLinkedChildren(Guid fromChildId, Guid toChildId);
-
-    /// <summary>
-    /// Creates or updates a LinkedChild entry linking a parent to a child item.
-    /// If the link already exists, updates the child type.
-    /// </summary>
-    /// <param name="parentId">The parent item ID.</param>
-    /// <param name="childId">The child item ID.</param>
-    /// <param name="childType">The type of linked child relationship.</param>
-    void UpsertLinkedChild(Guid parentId, Guid childId, LinkedChildType childType);
+    /// <param name="user">The user to check against.</param>
+    /// <param name="id">The top item id to check.</param>
+    /// <param name="recursive">Whether the check should be done recursively.</param>
+    /// <returns>A value indicating whether all children have been played.</returns>
+    bool GetIsPlayed(User user, Guid id, bool recursive);
 }
diff --git a/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs b/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
new file mode 100644
index 0000000000..d0cddf54a6
--- /dev/null
+++ b/MediaBrowser.Controller/Persistence/ILinkedChildrenService.cs
@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Controller.Entities.Audio;
+using LinkedChildType = MediaBrowser.Controller.Entities.LinkedChildType;
+
+namespace MediaBrowser.Controller.Persistence;
+
+/// <summary>
+/// Provides linked children query and manipulation operations.
+/// </summary>
+public interface ILinkedChildrenService
+{
+    /// <summary>
+    /// Gets the IDs of linked children for the specified parent.
+    /// </summary>
+    /// <param name="parentId">The parent item ID.</param>
+    /// <param name="childType">Optional child type filter.</param>
+    /// <returns>List of child item IDs.</returns>
+    IReadOnlyList<Guid> GetLinkedChildrenIds(Guid parentId, int? childType = null);
+
+    /// <summary>
+    /// Gets all artist matches from the database.
+    /// </summary>
+    /// <param name="artistNames">The names of the artists.</param>
+    /// <returns>A map of the artist name and the potential matches.</returns>
+    IReadOnlyDictionary<string, MusicArtist[]> FindArtists(IReadOnlyList<string> artistNames);
+
+    /// <summary>
+    /// Gets parent IDs that reference the specified child with LinkedChildType.Manual.
+    /// </summary>
+    /// <param name="childId">The child item ID.</param>
+    /// <returns>List of parent IDs that reference the child.</returns>
+    IReadOnlyList<Guid> GetManualLinkedParentIds(Guid childId);
+
+    /// <summary>
+    /// Updates LinkedChildren references from one child to another.
+    /// </summary>
+    /// <param name="fromChildId">The child ID to re-route from.</param>
+    /// <param name="toChildId">The child ID to re-route to.</param>
+    /// <returns>List of parent item IDs whose LinkedChildren were modified.</returns>
+    IReadOnlyList<Guid> RerouteLinkedChildren(Guid fromChildId, Guid toChildId);
+
+    /// <summary>
+    /// Creates or updates a LinkedChild entry.
+    /// </summary>
+    /// <param name="parentId">The parent item ID.</param>
+    /// <param name="childId">The child item ID.</param>
+    /// <param name="childType">The type of linked child relationship.</param>
+    void UpsertLinkedChild(Guid parentId, Guid childId, LinkedChildType childType);
+}
diff --git a/MediaBrowser.Controller/Persistence/INextUpService.cs b/MediaBrowser.Controller/Persistence/INextUpService.cs
new file mode 100644
index 0000000000..ade026d0da
--- /dev/null
+++ b/MediaBrowser.Controller/Persistence/INextUpService.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Persistence;
+
+/// <summary>
+/// Provides next-up episode query operations.
+/// </summary>
+public interface INextUpService
+{
+    /// <summary>
+    /// Gets the list of series presentation keys for next up.
+    /// </summary>
+    /// <param name="filter">The query.</param>
+    /// <param name="dateCutoff">The minimum date for a series to have been most recently watched.</param>
+    /// <returns>The list of keys.</returns>
+    IReadOnlyList<string> GetNextUpSeriesKeys(InternalItemsQuery filter, DateTime dateCutoff);
+
+    /// <summary>
+    /// Gets next up episodes for multiple series in a single batched query.
+    /// </summary>
+    /// <param name="filter">The query filter.</param>
+    /// <param name="seriesKeys">The series presentation unique keys to query.</param>
+    /// <param name="includeSpecials">Whether to include specials.</param>
+    /// <param name="includeWatchedForRewatching">Whether to include watched episodes for rewatching mode.</param>
+    /// <returns>A dictionary mapping series key to batch result.</returns>
+    IReadOnlyDictionary<string, NextUpEpisodeBatchResult> GetNextUpEpisodesBatch(
+        InternalItemsQuery filter,
+        IReadOnlyList<string> seriesKeys,
+        bool includeSpecials,
+        bool includeWatchedForRewatching);
+}
-- 
cgit v1.2.3


From a8a029de73dbdf5f281d434244b06a3561010ccf Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Wed, 11 Mar 2026 09:16:35 +0100
Subject: Fix DeleteItemsUnsafeFast usage

---
 Emby.Server.Implementations/Library/LibraryManager.cs | 10 +++++-----
 .../Library/Validators/ArtistsValidator.cs            | 19 +++++--------------
 .../Library/Validators/GenresValidator.cs             | 10 ++--------
 .../Library/Validators/PeopleValidator.cs             |  2 +-
 .../Library/Validators/StudiosValidator.cs            | 10 ++--------
 MediaBrowser.Controller/Library/ILibraryManager.cs    |  3 ++-
 6 files changed, 17 insertions(+), 37 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 8b715d3786..b8a0397b9e 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -34,14 +34,11 @@ using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.MediaEncoding;
-using MediaBrowser.Controller.MediaSegments;
 using MediaBrowser.Controller.Persistence;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Resolvers;
 using MediaBrowser.Controller.Sorting;
-using MediaBrowser.Controller.Trickplay;
 using MediaBrowser.Model.Configuration;
-using MediaBrowser.Model.Dlna;
 using MediaBrowser.Model.Drawing;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
@@ -343,9 +340,12 @@ namespace Emby.Server.Implementations.Library
             DeleteItem(item, options, parent, notifyParentItem);
         }
 
-        public void DeleteItemsUnsafeFast(IEnumerable<BaseItem> items)
+        public void DeleteItemsUnsafeFast(IReadOnlyCollection<BaseItem> items, bool deleteSourceFiles = false)
         {
-            var pathMaps = items.Select(e => (Item: e, InternalPath: GetInternalMetadataPaths(e), DeletePaths: e.GetDeletePaths())).ToArray();
+            var pathMaps = items.Select(e =>
+                (Item: e,
+                InternalPath: GetInternalMetadataPaths(e),
+                DeletePaths: deleteSourceFiles ? e.GetDeletePaths() : [])).ToArray();
 
             foreach (var (item, internalPaths, pathsToDelete) in pathMaps)
             {
diff --git a/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs b/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
index b196b1e038..02998cbff7 100644
--- a/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs
@@ -104,26 +104,17 @@ public class ArtistsValidator
             IncludeItemTypes = [BaseItemKind.MusicArtist],
             IsDeadArtist = true,
             IsLocked = false
-        }).Cast<MusicArtist>().ToList();
+        }).Cast<MusicArtist>()
+        .Where(item => item.IsAccessedByName)
+        .ToList();
 
         foreach (var item in deadEntities)
         {
-            if (!item.IsAccessedByName)
-            {
-                continue;
-            }
-
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }
diff --git a/Emby.Server.Implementations/Library/Validators/GenresValidator.cs b/Emby.Server.Implementations/Library/Validators/GenresValidator.cs
index badd6f1183..fc5a2fa0c5 100644
--- a/Emby.Server.Implementations/Library/Validators/GenresValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/GenresValidator.cs
@@ -114,16 +114,10 @@ public class GenresValidator
         foreach (var item in deadEntities)
         {
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }
diff --git a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
index f9a6f0d19e..dacef102dd 100644
--- a/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/PeopleValidator.cs
@@ -109,7 +109,7 @@ public class PeopleValidator
         var i = 0;
         foreach (var item in deadEntities.Chunk(500))
         {
-            _libraryManager.DeleteItemsUnsafeFast(item);
+            _libraryManager.DeleteItemsUnsafeFast(item, true);
             subProgress.Report(100f / deadEntities.Count * (i++ * 100));
         }
 
diff --git a/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs b/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
index 9fb6869171..88f86ae6ca 100644
--- a/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
+++ b/Emby.Server.Implementations/Library/Validators/StudiosValidator.cs
@@ -115,16 +115,10 @@ public class StudiosValidator
         foreach (var item in deadEntities)
         {
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index bcabfff772..5c391098d3 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -391,8 +391,9 @@ namespace MediaBrowser.Controller.Library
         /// Deletes items that are not having any children like Actors.
         /// </summary>
         /// <param name="items">Items to delete.</param>
+        /// <param name="deleteSourceFiles">Whether to delete source media files on disk. Defaults to false.</param>
         /// <remarks>In comparison to <see cref="DeleteItem(BaseItem, DeleteOptions, BaseItem, bool)"/> this method skips a lot of steps assuming there are no children to recusively delete nor does it define the special handling for channels and alike.</remarks>
-        public void DeleteItemsUnsafeFast(IEnumerable<BaseItem> items);
+        public void DeleteItemsUnsafeFast(IReadOnlyCollection<BaseItem> items, bool deleteSourceFiles = false);
 
         /// <summary>
         /// Deletes the item.
-- 
cgit v1.2.3


From 352b6c91f84798c66bfa2d8f84ff69cfd04ad04a Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Wed, 11 Mar 2026 15:39:04 +0100
Subject: Safeguard against empty list

---
 Emby.Server.Implementations/Library/LibraryManager.cs | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index b8a0397b9e..11a6f58800 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -342,6 +342,11 @@ namespace Emby.Server.Implementations.Library
 
         public void DeleteItemsUnsafeFast(IReadOnlyCollection<BaseItem> items, bool deleteSourceFiles = false)
         {
+            if (items.Count == 0)
+            {
+                return;
+            }
+
             var pathMaps = items.Select(e =>
                 (Item: e,
                 InternalPath: GetInternalMetadataPaths(e),
-- 
cgit v1.2.3


From ebc15d3e279d52a55f49e4de5aca2153f64ac636 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sat, 14 Mar 2026 20:26:20 +0100
Subject: Handle removed alternates

---
 .../Library/LibraryManager.cs                      | 32 +++++++++++++++++++++-
 1 file changed, 31 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 11a6f58800..57db845cb2 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -432,13 +432,43 @@ namespace Emby.Server.Implementations.Library
             if (item is Video video && !video.PrimaryVersionId.HasValue && video.OwnerId.IsEmpty())
             {
                 var localAlternateIds = GetLocalAlternateVersionIds(video).ToHashSet();
-                var alternateVersions = localAlternateIds
+                var allAlternateVersions = localAlternateIds
                     .Concat(GetLinkedAlternateVersions(video).Select(v => v.Id))
                     .Distinct()
                     .Select(id => GetItemById(id))
                     .OfType<Video>()
                     .ToList();
 
+                // Partition alternates by whether their files still exist on disk
+                var alternateVersions = new List<Video>();
+                var missingAlternates = new List<Video>();
+                foreach (var alt in allAlternateVersions)
+                {
+                    if (!string.IsNullOrEmpty(alt.Path) && !_fileSystem.FileExists(alt.Path))
+                    {
+                        missingAlternates.Add(alt);
+                    }
+                    else
+                    {
+                        alternateVersions.Add(alt);
+                    }
+                }
+
+                // Delete alternates whose files no longer exist to avoid ghost items.
+                // Clear PrimaryVersionId first so DeleteItem doesn't try to update the primary being deleted.
+                foreach (var missing in missingAlternates)
+                {
+                    _logger.LogInformation(
+                        "Deleting missing alternate version {Name} ({Path})",
+                        missing.Name ?? "Unknown name",
+                        missing.Path ?? string.Empty);
+                    missing.SetPrimaryVersionId(null);
+                    missing.OwnerId = Guid.Empty;
+                    missing.LocalAlternateVersions = [];
+                    missing.LinkedAlternateVersions = [];
+                    DeleteItem(missing, new DeleteOptions { DeleteFileLocation = false }, false);
+                }
+
                 if (alternateVersions.Count > 0)
                 {
                     _logger.LogInformation(
-- 
cgit v1.2.3


From 99ad70fbc81c128f5859081a3b51da8db2d78726 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Wed, 1 Apr 2026 18:01:25 +0200
Subject: Wrap method parameters

---
 Emby.Server.Implementations/Dto/DtoService.cs      | 48 +++++++++++++++++++---
 .../Library/LibraryManager.cs                      |  6 ++-
 MediaBrowser.Controller/Dto/IDtoService.cs         |  7 +++-
 MediaBrowser.Controller/Entities/BaseItem.cs       |  8 +++-
 MediaBrowser.Controller/Entities/Folder.cs         |  8 +++-
 .../Entities/UserViewBuilder.cs                    |  7 +++-
 MediaBrowser.Controller/Entities/Video.cs          | 23 +++++++++--
 7 files changed, 92 insertions(+), 15 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 07938d172f..919733d2ad 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -153,7 +153,12 @@ namespace Emby.Server.Implementations.Dto
         private ILiveTvManager LivetvManager => _livetvManagerFactory.Value;
 
         /// <inheritdoc />
-        public IReadOnlyList<BaseItemDto> GetBaseItemDtos(IReadOnlyList<BaseItem> items, DtoOptions options, User? user = null, BaseItem? owner = null, bool skipVisibilityCheck = false)
+        public IReadOnlyList<BaseItemDto> GetBaseItemDtos(
+            IReadOnlyList<BaseItem> items,
+            DtoOptions options,
+            User? user = null,
+            BaseItem? owner = null,
+            bool skipVisibilityCheck = false)
         {
             var accessibleItems = skipVisibilityCheck || user is null ? items : items.Where(x => x.IsVisible(user)).ToList();
             var returnItems = new BaseItemDto[accessibleItems.Count];
@@ -201,7 +206,15 @@ namespace Emby.Server.Implementations.Dto
             for (int index = 0; index < accessibleItems.Count; index++)
             {
                 var item = accessibleItems[index];
-                var dto = GetBaseItemDtoInternal(item, options, user, owner, userDataBatch?.GetValueOrDefault(item.Id), allCollectionFolders, childCountBatch, playedCountBatch);
+                var dto = GetBaseItemDtoInternal(
+                    item,
+                    options,
+                    user,
+                    owner,
+                    userDataBatch?.GetValueOrDefault(item.Id),
+                    allCollectionFolders,
+                    childCountBatch,
+                    playedCountBatch);
 
                 if (item is LiveTvChannel tvChannel)
                 {
@@ -253,7 +266,15 @@ namespace Emby.Server.Implementations.Dto
             return dto;
         }
 
-        private BaseItemDto GetBaseItemDtoInternal(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner = null, UserItemData? userData = null, List<Folder>? allCollectionFolders = null, Dictionary<Guid, int>? childCountBatch = null, Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null)
+        private BaseItemDto GetBaseItemDtoInternal(
+            BaseItem item,
+            DtoOptions options,
+            User? user = null,
+            BaseItem? owner = null,
+            UserItemData? userData = null,
+            List<Folder>? allCollectionFolders = null,
+            Dictionary<Guid, int>? childCountBatch = null,
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null)
         {
             var dto = new BaseItemDto
             {
@@ -290,7 +311,14 @@ namespace Emby.Server.Implementations.Dto
 
             if (user is not null)
             {
-                AttachUserSpecificInfo(dto, item, user, options, userData, childCountBatch, playedCountBatch);
+                AttachUserSpecificInfo(
+                    dto,
+                    item,
+                    user,
+                    options,
+                    userData,
+                    childCountBatch,
+                    playedCountBatch);
             }
 
             if (item is IHasMediaSources
@@ -468,7 +496,14 @@ namespace Emby.Server.Implementations.Dto
         /// <summary>
         /// Attaches the user specific info.
         /// </summary>
-        private void AttachUserSpecificInfo(BaseItemDto dto, BaseItem item, User user, DtoOptions options, UserItemData? userData = null, Dictionary<Guid, int>? childCountBatch = null, Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null)
+        private void AttachUserSpecificInfo(
+            BaseItemDto dto,
+            BaseItem item,
+            User user,
+            DtoOptions options,
+            UserItemData? userData = null,
+            Dictionary<Guid, int>? childCountBatch = null,
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null)
         {
             if (item.IsFolder)
             {
@@ -480,7 +515,8 @@ namespace Emby.Server.Implementations.Dto
                     {
                         // Use pre-fetched user data
                         dto.UserData = GetUserItemDataDto(userData, item.Id);
-                        (int Played, int Total)? precomputed = playedCountBatch is not null && playedCountBatch.TryGetValue(item.Id, out var counts) ? counts : null;
+                        (int Played, int Total)? precomputed = playedCountBatch is not null
+                            && playedCountBatch.TryGetValue(item.Id, out var counts) ? counts : null;
                         item.FillUserDataDtoValues(dto.UserData, userData, dto, user, options, precomputed);
                     }
                     else
diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 57db845cb2..5d24bffa2f 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -774,7 +774,11 @@ namespace Emby.Server.Implementations.Library
             return key.GetMD5();
         }
 
-        public BaseItem? ResolvePath(FileSystemMetadata fileInfo, Folder? parent = null, IDirectoryService? directoryService = null, CollectionType? collectionType = null)
+        public BaseItem? ResolvePath(
+            FileSystemMetadata fileInfo,
+            Folder? parent = null,
+            IDirectoryService? directoryService = null,
+            CollectionType? collectionType = null)
             => ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent, collectionType);
 
         /// <inheritdoc />
diff --git a/MediaBrowser.Controller/Dto/IDtoService.cs b/MediaBrowser.Controller/Dto/IDtoService.cs
index 8dc6f0aa68..f735abb09f 100644
--- a/MediaBrowser.Controller/Dto/IDtoService.cs
+++ b/MediaBrowser.Controller/Dto/IDtoService.cs
@@ -38,7 +38,12 @@ namespace MediaBrowser.Controller.Dto
         /// <param name="owner">The owner.</param>
         /// <param name="skipVisibilityCheck">Skip redundant visibility check if items are already filtered.</param>
         /// <returns>The <see cref="IReadOnlyList{T}"/> of <see cref="BaseItemDto"/>.</returns>
-        IReadOnlyList<BaseItemDto> GetBaseItemDtos(IReadOnlyList<BaseItem> items, DtoOptions options, User? user = null, BaseItem? owner = null, bool skipVisibilityCheck = false);
+        IReadOnlyList<BaseItemDto> GetBaseItemDtos(
+            IReadOnlyList<BaseItem> items,
+            DtoOptions options,
+            User? user = null,
+            BaseItem? owner = null,
+            bool skipVisibilityCheck = false);
 
         /// <summary>
         /// Gets the item by name dto.
diff --git a/MediaBrowser.Controller/Entities/BaseItem.cs b/MediaBrowser.Controller/Entities/BaseItem.cs
index d963ba53f7..30e26470d6 100644
--- a/MediaBrowser.Controller/Entities/BaseItem.cs
+++ b/MediaBrowser.Controller/Entities/BaseItem.cs
@@ -2477,7 +2477,13 @@ namespace MediaBrowser.Controller.Entities
             return path;
         }
 
-        public virtual void FillUserDataDtoValues(UserItemDataDto dto, UserItemData userData, BaseItemDto itemDto, User user, DtoOptions fields, (int Played, int Total)? precomputedCounts = null)
+        public virtual void FillUserDataDtoValues(
+            UserItemDataDto dto,
+            UserItemData userData,
+            BaseItemDto itemDto,
+            User user,
+            DtoOptions fields,
+            (int Played, int Total)? precomputedCounts = null)
         {
             if (RunTimeTicks.HasValue)
             {
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index fbb18afa9e..3b20dc85fe 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -1859,7 +1859,13 @@ namespace MediaBrowser.Controller.Entities
             return !IsPlayed(user, userItemData);
         }
 
-        public override void FillUserDataDtoValues(UserItemDataDto dto, UserItemData userData, BaseItemDto itemDto, User user, DtoOptions fields, (int Played, int Total)? precomputedCounts = null)
+        public override void FillUserDataDtoValues(
+            UserItemDataDto dto,
+            UserItemData userData,
+            BaseItemDto itemDto,
+            User user,
+            DtoOptions fields,
+            (int Played, int Total)? precomputedCounts = null)
         {
             if (!SupportsUserDataFromChildren)
             {
diff --git a/MediaBrowser.Controller/Entities/UserViewBuilder.cs b/MediaBrowser.Controller/Entities/UserViewBuilder.cs
index 77bdf402e4..cb05056601 100644
--- a/MediaBrowser.Controller/Entities/UserViewBuilder.cs
+++ b/MediaBrowser.Controller/Entities/UserViewBuilder.cs
@@ -493,7 +493,12 @@ namespace MediaBrowser.Controller.Entities
                 itemsArray);
         }
 
-        private static bool Filter(BaseItem item, User user, InternalItemsQuery query, IUserDataManager userDataManager, ILibraryManager libraryManager)
+        private static bool Filter(
+            BaseItem item,
+            User user,
+            InternalItemsQuery query,
+            IUserDataManager userDataManager,
+            ILibraryManager libraryManager)
         {
             if (!string.IsNullOrEmpty(query.NameStartsWith) && !item.SortName.StartsWith(query.NameStartsWith, StringComparison.InvariantCultureIgnoreCase))
             {
diff --git a/MediaBrowser.Controller/Entities/Video.cs b/MediaBrowser.Controller/Entities/Video.cs
index 58dd3b8745..80bcd62dcd 100644
--- a/MediaBrowser.Controller/Entities/Video.cs
+++ b/MediaBrowser.Controller/Entities/Video.cs
@@ -461,7 +461,11 @@ namespace MediaBrowser.Controller.Entities
             return hasChanges;
         }
 
-        private async Task RefreshMetadataForVersions(MetadataRefreshOptions options, bool copyTitleMetadata, string path, CancellationToken cancellationToken)
+        private async Task RefreshMetadataForVersions(
+            MetadataRefreshOptions options,
+            bool copyTitleMetadata,
+            string path,
+            CancellationToken cancellationToken)
         {
             // Ensure the alternate version exists with the correct type (e.g. Movie, not Video)
             // before refreshing. This must happen here rather than in RefreshMetadataForOwnedVideo
@@ -498,10 +502,19 @@ namespace MediaBrowser.Controller.Entities
             }
         }
 
-        private new Task RefreshMetadataForOwnedVideo(MetadataRefreshOptions options, bool copyTitleMetadata, string path, CancellationToken cancellationToken)
+        private new Task RefreshMetadataForOwnedVideo(
+            MetadataRefreshOptions options,
+            bool copyTitleMetadata,
+            string path,
+            CancellationToken cancellationToken)
             => RefreshMetadataForOwnedVideo(options, copyTitleMetadata, path, GetType(), cancellationToken);
 
-        private async Task RefreshMetadataForOwnedVideo(MetadataRefreshOptions options, bool copyTitleMetadata, string path, Type itemType, CancellationToken cancellationToken)
+        private async Task RefreshMetadataForOwnedVideo(
+            MetadataRefreshOptions options,
+            bool copyTitleMetadata,
+            string path,
+            Type itemType,
+            CancellationToken cancellationToken)
         {
             var newOptions = new MetadataRefreshOptions(options)
             {
@@ -624,7 +637,9 @@ namespace MediaBrowser.Controller.Entities
                 (this, MediaSourceType.Default)
             };
 
-            list.AddRange(LibraryManager.GetLinkedAlternateVersions(this).Select(i => ((BaseItem)i, MediaSourceType.Grouping)));
+            list.AddRange(
+                LibraryManager.GetLinkedAlternateVersions(this)
+                    .Select(i => ((BaseItem)i, MediaSourceType.Grouping)));
 
             if (PrimaryVersionId.HasValue)
             {
-- 
cgit v1.2.3


From d8bbb4dfe8e614dd8754d83c622a4964af1d21f6 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sat, 11 Apr 2026 15:44:52 +0200
Subject: Fix filters

---
 .../Library/LibraryManager.cs                      |   6 ++
 Jellyfin.Api/Controllers/FilterController.cs       |   8 +-
 Jellyfin.Api/Controllers/ItemsController.cs        |  12 +++
 .../Item/BaseItemRepository.TranslateQuery.cs      | 118 ++++++++++++++-------
 4 files changed, 102 insertions(+), 42 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 92f3c98d3a..2bcb10e9e1 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -3747,6 +3747,12 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public QueryFiltersLegacy GetQueryFiltersLegacy(InternalItemsQuery query)
         {
+            if (query.User is not null)
+            {
+                AddUserToQuery(query, query.User);
+            }
+
+            SetTopParentOrAncestorIds(query);
             return _itemRepository.GetQueryFiltersLegacy(query);
         }
     }
diff --git a/Jellyfin.Api/Controllers/FilterController.cs b/Jellyfin.Api/Controllers/FilterController.cs
index 5ad127ad8c..2f53784db1 100644
--- a/Jellyfin.Api/Controllers/FilterController.cs
+++ b/Jellyfin.Api/Controllers/FilterController.cs
@@ -60,9 +60,7 @@ public class FilterController : BaseJellyfinApiController
 
         BaseItem? item = null;
         if (includeItemTypes.Length != 1
-            || !(includeItemTypes[0] == BaseItemKind.BoxSet
-                 || includeItemTypes[0] == BaseItemKind.Playlist
-                 || includeItemTypes[0] == BaseItemKind.Trailer
+            || !(includeItemTypes[0] == BaseItemKind.Trailer
                  || includeItemTypes[0] == BaseItemKind.Program))
         {
             item = _libraryManager.GetParentItem(parentId, user?.Id);
@@ -127,9 +125,7 @@ public class FilterController : BaseJellyfinApiController
 
         BaseItem? parentItem = null;
         if (includeItemTypes.Length == 1
-            && (includeItemTypes[0] == BaseItemKind.BoxSet
-                || includeItemTypes[0] == BaseItemKind.Playlist
-                || includeItemTypes[0] == BaseItemKind.Trailer
+            && (includeItemTypes[0] == BaseItemKind.Trailer
                 || includeItemTypes[0] == BaseItemKind.Program))
         {
             parentItem = null;
diff --git a/Jellyfin.Api/Controllers/ItemsController.cs b/Jellyfin.Api/Controllers/ItemsController.cs
index d2fb1cd294..97183f09d4 100644
--- a/Jellyfin.Api/Controllers/ItemsController.cs
+++ b/Jellyfin.Api/Controllers/ItemsController.cs
@@ -299,6 +299,18 @@ public class ItemsController : BaseJellyfinApiController
             recursive = true;
             includeItemTypes = new[] { BaseItemKind.Playlist };
         }
+        else if (folder is ICollectionFolder && includeItemTypes.Length == 0)
+        {
+            // When the client doesn't specify recursive/includeItemTypes, force the query
+            // through the database path where all filters (IsHD, genres, etc.) are applied.
+            recursive = true;
+            includeItemTypes = collectionType switch
+            {
+                CollectionType.boxsets => [BaseItemKind.BoxSet],
+                null => [BaseItemKind.Movie, BaseItemKind.Series], // mixed
+                _ => []
+            };
+        }
 
         if (item is not UserRootFolder
             // api keys can always access all folders
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
index c1c7e6cd95..664befc2ef 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
@@ -66,10 +66,27 @@ public sealed partial class BaseItemRepository
                 include4K = true;
             }
 
+            // Non-folders: check own resolution directly (no subquery).
+            // Folders (Series, BoxSets): EXISTS check on descendants/linked children.
+            // Using navigation properties (a.Item, lc.Child) produces efficient
+            // EXISTS + JOIN instead of nested IN (SELECT ...) subqueries.
             baseQuery = baseQuery.Where(e =>
-                (includeSD && e.Width < HDWidth) ||
-                (includeHD && e.Width >= HDWidth && !(e.Width >= UHDWidth || e.Height >= UHDHeight)) ||
-                (include4K && (e.Width >= UHDWidth || e.Height >= UHDHeight)));
+                (!e.IsFolder && e.Width > 0
+                    && ((includeSD && e.Width < HDWidth)
+                        || (includeHD && e.Width >= HDWidth && !(e.Width >= UHDWidth || e.Height >= UHDHeight))
+                        || (include4K && (e.Width >= UHDWidth || e.Height >= UHDHeight))))
+                || (e.IsFolder
+                    && (e.Children!.Any(a =>
+                            a.Item.Width > 0
+                            && ((includeSD && a.Item.Width < HDWidth)
+                                || (includeHD && a.Item.Width >= HDWidth && !(a.Item.Width >= UHDWidth || a.Item.Height >= UHDHeight))
+                                || (include4K && (a.Item.Width >= UHDWidth || a.Item.Height >= UHDHeight))))
+                        || context.LinkedChildren.Any(lc =>
+                            lc.ParentId == e.Id
+                            && lc.Child!.Width > 0
+                            && ((includeSD && lc.Child.Width < HDWidth)
+                                || (includeHD && lc.Child.Width >= HDWidth && !(lc.Child.Width >= UHDWidth || lc.Child.Height >= UHDHeight))
+                                || (include4K && (lc.Child.Width >= UHDWidth || lc.Child.Height >= UHDHeight)))))));
         }
 
         if (minWidth.HasValue)
@@ -443,44 +460,63 @@ public sealed partial class BaseItemRepository
 
         if (filter.IsPlayed.HasValue)
         {
-            // We should probably figure this out for all folders, but for right now, this is the only place where we need it
-            if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.Series)
+            var hasSeries = filter.IncludeItemTypes.Contains(BaseItemKind.Series);
+            var hasBoxSet = filter.IncludeItemTypes.Contains(BaseItemKind.BoxSet);
+
+            if (hasSeries || hasBoxSet)
             {
                 var userId = filter.User!.Id;
-                var seriesWithEpisodes = context.BaseItems
-                    .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue)
-                    .Select(e => e.SeriesId!.Value)
-                    .Distinct();
+                var isPlayed = filter.IsPlayed.Value;
+                var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];
+                var boxSetTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.BoxSet];
+
+                // Series: played = all episodes played, unplayed = any episode unplayed
+                var seriesWithEpisodes = hasSeries
+                    ? context.BaseItems
+                        .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue)
+                        .Select(e => e.SeriesId!.Value)
+                        .Distinct()
+                    : Enumerable.Empty<Guid>().AsQueryable();
+
+                var seriesWithUnplayedEpisodes = hasSeries
+                    ? context.BaseItems
+                        .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue
+                            && !e.UserData!.Any(ud => ud.UserId == userId && ud.Played))
+                        .Select(e => e.SeriesId!.Value)
+                        .Distinct()
+                    : Enumerable.Empty<Guid>().AsQueryable();
+
+                // BoxSet: played = all children played
+                IEnumerable<Guid> playedBoxSetIds = [];
+                if (hasBoxSet)
+                {
+                    var boxSetIds = baseQuery.Where(e => e.Type == boxSetTypeName).Select(e => e.Id).ToList();
+                    var playedCounts = GetPlayedAndTotalCountBatch(boxSetIds, filter.User!);
+                    playedBoxSetIds = playedCounts
+                        .Where(kvp => kvp.Value.Total > 0 && kvp.Value.Played == kvp.Value.Total)
+                        .Select(kvp => kvp.Key);
+                }
 
-                var seriesWithUnplayedEpisodes = context.BaseItems
-                    .Where(e => !e.IsFolder && !e.IsVirtualItem && e.SeriesId.HasValue
-                        && !e.UserData!.Any(ud => ud.UserId == userId && ud.Played))
-                    .Select(e => e.SeriesId!.Value)
-                    .Distinct();
+                // Non-folder items: check UserData directly
+                var playedItemIds = context.UserData
+                    .Where(ud => ud.UserId == userId && ud.Played)
+                    .Select(ud => ud.ItemId);
 
-                var isPlayed = filter.IsPlayed.Value;
                 if (isPlayed)
                 {
-                    baseQuery = baseQuery.Where(s =>
-                        seriesWithEpisodes.Contains(s.Id) && !seriesWithUnplayedEpisodes.Contains(s.Id));
+                    baseQuery = baseQuery.Where(e =>
+                        (e.Type == seriesTypeName && seriesWithEpisodes.Contains(e.Id) && !seriesWithUnplayedEpisodes.Contains(e.Id))
+                        || (e.Type == boxSetTypeName && playedBoxSetIds.Contains(e.Id))
+                        || (e.Type != seriesTypeName && e.Type != boxSetTypeName && playedItemIds.Contains(e.Id)));
                 }
                 else
                 {
-                    baseQuery = baseQuery.Where(s =>
-                        !seriesWithEpisodes.Contains(s.Id) || seriesWithUnplayedEpisodes.Contains(s.Id));
+                    baseQuery = baseQuery.Where(e =>
+                        (e.Type == seriesTypeName && (!seriesWithEpisodes.Contains(e.Id) || seriesWithUnplayedEpisodes.Contains(e.Id)))
+                        || (e.Type == boxSetTypeName && !playedBoxSetIds.Contains(e.Id))
+                        || (e.Type != seriesTypeName && e.Type != boxSetTypeName && !playedItemIds.Contains(e.Id)));
                 }
             }
-            else if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.BoxSet)
-            {
-                var boxSetIds = baseQuery.Select(e => e.Id).ToList();
-                var playedCounts = GetPlayedAndTotalCountBatch(boxSetIds, filter.User!);
-                var playedBoxSetIds = playedCounts
-                    .Where(kvp => kvp.Value.Total > 0 && kvp.Value.Played == kvp.Value.Total)
-                    .Select(kvp => kvp.Key);
-
-                var isPlayedBoxSet = filter.IsPlayed.Value;
-                baseQuery = baseQuery.Where(s => playedBoxSetIds.Contains(s.Id) == isPlayedBoxSet);
-            }
             else
             {
                 var playedItemIds = context.UserData
@@ -493,9 +529,13 @@ public sealed partial class BaseItemRepository
 
         if (filter.IsResumable.HasValue)
         {
-            if (filter.IncludeItemTypes.Length == 1 && filter.IncludeItemTypes[0] == BaseItemKind.Series)
+            var hasSeries = filter.IncludeItemTypes.Contains(BaseItemKind.Series);
+
+            if (hasSeries)
             {
                 var userId = filter.User!.Id;
+                var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];
+                var isResumable = filter.IsResumable.Value;
 
                 // Series with at least one in-progress episode.
                 var seriesWithInProgressEpisodes = context.BaseItems
@@ -518,14 +558,20 @@ public sealed partial class BaseItemRepository
                     .Select(e => e.SeriesId!.Value)
                     .Distinct();
 
-                var isResumable = filter.IsResumable.Value;
+                // Non-series items: resumable if PlaybackPositionTicks > 0
+                var resumableItemIds = context.UserData
+                    .Where(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0)
+                    .Select(ud => ud.ItemId);
 
                 // A series is resumable if it has an in-progress episode,
                 // or if it has both played and unplayed episodes (partially watched).
-                baseQuery = baseQuery.Where(s =>
-                    (seriesWithInProgressEpisodes.Contains(s.Id)
-                        || (seriesWithPlayedEpisodes.Contains(s.Id) && seriesWithUnplayedEpisodes.Contains(s.Id)))
-                    == isResumable);
+                baseQuery = baseQuery.Where(e =>
+                    (e.Type == seriesTypeName
+                        && (seriesWithInProgressEpisodes.Contains(e.Id)
+                            || (seriesWithPlayedEpisodes.Contains(e.Id) && seriesWithUnplayedEpisodes.Contains(e.Id)))
+                        == isResumable)
+                    || (e.Type != seriesTypeName
+                        && resumableItemIds.Contains(e.Id) == isResumable));
             }
             else
             {
-- 
cgit v1.2.3


From d20c775dafba32dce65f8d68fb6802732df00363 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sun, 1 Feb 2026 23:07:01 +0100
Subject: Implement ignore rule caching

---
 Emby.Server.Implementations/ApplicationHost.cs     |   1 +
 Emby.Server.Implementations/IO/LibraryMonitor.cs   |   8 +-
 .../Library/DotIgnoreIgnoreRule.cs                 | 272 ++++++++++++--
 .../Library/LibraryManager.cs                      |  19 +-
 .../Controllers/LibraryStructureController.cs      |   4 +
 MediaBrowser.Controller/Library/ILibraryManager.cs |   7 +
 MediaBrowser.Providers/Manager/ProviderManager.cs  |   2 +
 .../Library/DotIgnoreIgnoreRuleTest.cs             | 392 +++++++++++++++++++++
 8 files changed, 663 insertions(+), 42 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/ApplicationHost.cs b/Emby.Server.Implementations/ApplicationHost.cs
index e8cab6ea8c..b7aa2f3d06 100644
--- a/Emby.Server.Implementations/ApplicationHost.cs
+++ b/Emby.Server.Implementations/ApplicationHost.cs
@@ -536,6 +536,7 @@ namespace Emby.Server.Implementations
             serviceCollection.AddSingleton<IMusicManager, MusicManager>();
 
             serviceCollection.AddSingleton<ILibraryMonitor, LibraryMonitor>();
+            serviceCollection.AddSingleton<DotIgnoreIgnoreRule>();
 
             serviceCollection.AddSingleton<ISearchEngine, SearchEngine>();
 
diff --git a/Emby.Server.Implementations/IO/LibraryMonitor.cs b/Emby.Server.Implementations/IO/LibraryMonitor.cs
index 23bd5cf200..1bf0f8c76c 100644
--- a/Emby.Server.Implementations/IO/LibraryMonitor.cs
+++ b/Emby.Server.Implementations/IO/LibraryMonitor.cs
@@ -21,6 +21,7 @@ namespace Emby.Server.Implementations.IO
         private readonly ILibraryManager _libraryManager;
         private readonly IServerConfigurationManager _configurationManager;
         private readonly IFileSystem _fileSystem;
+        private readonly DotIgnoreIgnoreRule _dotIgnoreIgnoreRule;
 
         /// <summary>
         /// The file system watchers.
@@ -47,17 +48,20 @@ namespace Emby.Server.Implementations.IO
         /// <param name="configurationManager">The configuration manager.</param>
         /// <param name="fileSystem">The filesystem.</param>
         /// <param name="appLifetime">The <see cref="IHostApplicationLifetime"/>.</param>
+        /// <param name="dotIgnoreIgnoreRule">The .ignore rule handler.</param>
         public LibraryMonitor(
             ILogger<LibraryMonitor> logger,
             ILibraryManager libraryManager,
             IServerConfigurationManager configurationManager,
             IFileSystem fileSystem,
-            IHostApplicationLifetime appLifetime)
+            IHostApplicationLifetime appLifetime,
+            DotIgnoreIgnoreRule dotIgnoreIgnoreRule)
         {
             _libraryManager = libraryManager;
             _logger = logger;
             _configurationManager = configurationManager;
             _fileSystem = fileSystem;
+            _dotIgnoreIgnoreRule = dotIgnoreIgnoreRule;
 
             appLifetime.ApplicationStarted.Register(Start);
             appLifetime.ApplicationStopping.Register(Stop);
@@ -354,7 +358,7 @@ namespace Emby.Server.Implementations.IO
             }
 
             var fileInfo = _fileSystem.GetFileSystemInfo(path);
-            if (DotIgnoreIgnoreRule.IsIgnored(fileInfo, null))
+            if (_dotIgnoreIgnoreRule.ShouldIgnore(fileInfo, null))
             {
                 return;
             }
diff --git a/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs b/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs
index ef5d24c70f..f073fc0bca 100644
--- a/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs
+++ b/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs
@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Text.RegularExpressions;
+using BitFaster.Caching.Lru;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Resolvers;
@@ -15,22 +16,36 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
 {
     private static readonly bool IsWindows = OperatingSystem.IsWindows();
 
-    private static FileInfo? FindIgnoreFile(DirectoryInfo directory)
-    {
-        for (var current = directory; current is not null; current = current.Parent)
-        {
-            var ignorePath = Path.Join(current.FullName, ".ignore");
-            if (File.Exists(ignorePath))
-            {
-                return new FileInfo(ignorePath);
-            }
-        }
+    private readonly FastConcurrentLru<string, IgnoreFileCacheEntry> _directoryCache;
+    private readonly FastConcurrentLru<string, ParsedIgnoreCacheEntry> _rulesCache;
 
-        return null;
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DotIgnoreIgnoreRule"/> class.
+    /// </summary>
+    public DotIgnoreIgnoreRule()
+    {
+        var cacheSize = Math.Max(100, Environment.ProcessorCount * 100);
+        _directoryCache = new FastConcurrentLru<string, IgnoreFileCacheEntry>(
+            Environment.ProcessorCount,
+            cacheSize,
+            StringComparer.Ordinal);
+        _rulesCache = new FastConcurrentLru<string, ParsedIgnoreCacheEntry>(
+            Environment.ProcessorCount,
+            Math.Max(32, cacheSize / 4),
+            StringComparer.Ordinal);
     }
 
     /// <inheritdoc />
-    public bool ShouldIgnore(FileSystemMetadata fileInfo, BaseItem? parent) => IsIgnored(fileInfo, parent);
+    public bool ShouldIgnore(FileSystemMetadata fileInfo, BaseItem? parent) => IsIgnoredInternal(fileInfo, parent);
+
+    /// <summary>
+    /// Clears the directory lookup cache. The parsed rules cache is not cleared
+    /// as it validates file modification time on each access.
+    /// </summary>
+    public void ClearDirectoryCache()
+    {
+        _directoryCache.Clear();
+    }
 
     /// <summary>
     /// Checks whether or not the file is ignored.
@@ -38,40 +53,38 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
     /// <param name="fileInfo">The file information.</param>
     /// <param name="parent">The parent BaseItem.</param>
     /// <returns>True if the file should be ignored.</returns>
-    public static bool IsIgnored(FileSystemMetadata fileInfo, BaseItem? parent)
+    public bool IsIgnoredInternal(FileSystemMetadata fileInfo, BaseItem? parent)
     {
         var searchDirectory = fileInfo.IsDirectory
-            ? new DirectoryInfo(fileInfo.FullName)
-            : new DirectoryInfo(Path.GetDirectoryName(fileInfo.FullName) ?? string.Empty);
+            ? fileInfo.FullName
+            : Path.GetDirectoryName(fileInfo.FullName);
 
-        if (string.IsNullOrEmpty(searchDirectory.FullName))
+        if (string.IsNullOrEmpty(searchDirectory))
         {
             return false;
         }
 
-        var ignoreFile = FindIgnoreFile(searchDirectory);
-        if (ignoreFile is null)
+        var ignoreFilePath = FindIgnoreFileCached(searchDirectory);
+        if (ignoreFilePath is null)
         {
             return false;
         }
 
-        // Fast path in case the ignore files isn't a symlink and is empty
-        if (ignoreFile.LinkTarget is null && ignoreFile.Length == 0)
+        var parsedEntry = GetParsedRules(ignoreFilePath);
+        if (parsedEntry is null)
         {
-            // Ignore directory if we just have the file
-            return true;
+            // File was deleted after we cached the path - clear the directory cache entry and return false
+            _directoryCache.TryRemove(searchDirectory, out _);
+            return false;
         }
 
-        var content = GetFileContent(ignoreFile);
-        return string.IsNullOrWhiteSpace(content)
-            || CheckIgnoreRules(fileInfo.FullName, content, fileInfo.IsDirectory);
-    }
+        // Empty file means ignore everything
+        if (parsedEntry.IsEmpty)
+        {
+            return true;
+        }
 
-    private static bool CheckIgnoreRules(string path, string ignoreFileContent, bool isDirectory)
-    {
-        // If file has content, base ignoring off the content .gitignore-style rules
-        var rules = ignoreFileContent.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
-        return CheckIgnoreRules(path, rules, isDirectory);
+        return parsedEntry.Rules.IsIgnored(GetPathToCheck(fileInfo.FullName, fileInfo.IsDirectory));
     }
 
     /// <summary>
@@ -117,8 +130,8 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
             return true;
         }
 
-         // Mitigate the problem of the Ignore library not handling Windows paths correctly.
-         // See https://github.com/jellyfin/jellyfin/issues/15484
+        // Mitigate the problem of the Ignore library not handling Windows paths correctly.
+        // See https://github.com/jellyfin/jellyfin/issues/15484
         var pathToCheck = normalizePath ? path.NormalizePath('/') : path;
 
         // Add trailing slash for directories to match "folder/"
@@ -130,11 +143,194 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
         return ignore.IsIgnored(pathToCheck);
     }
 
-    private static string GetFileContent(FileInfo ignoreFile)
+    private string? FindIgnoreFileCached(string directory)
+    {
+        // Check if we have a cached result for this directory
+        if (_directoryCache.TryGet(directory, out var cached))
+        {
+            return cached.IgnoreFilePath;
+        }
+
+        // Walk up the directory tree to find .ignore file
+        var current = directory;
+        var checkedDirs = new System.Collections.Generic.List<string> { directory };
+
+        while (!string.IsNullOrEmpty(current))
+        {
+            // Check if this intermediate directory is cached
+            if (current != directory && _directoryCache.TryGet(current, out var parentCached))
+            {
+                // Cache the result for all directories we checked
+                var entry = new IgnoreFileCacheEntry(parentCached.IgnoreFilePath);
+                foreach (var dir in checkedDirs)
+                {
+                    _directoryCache.AddOrUpdate(dir, entry);
+                }
+
+                return parentCached.IgnoreFilePath;
+            }
+
+            var ignorePath = Path.Join(current, ".ignore");
+            if (File.Exists(ignorePath))
+            {
+                // Cache for all directories we checked
+                var entry = new IgnoreFileCacheEntry(ignorePath);
+                foreach (var dir in checkedDirs)
+                {
+                    _directoryCache.AddOrUpdate(dir, entry);
+                }
+
+                return ignorePath;
+            }
+
+            var parent = Path.GetDirectoryName(current);
+            if (parent == current || string.IsNullOrEmpty(parent))
+            {
+                break;
+            }
+
+            current = parent;
+            checkedDirs.Add(current);
+        }
+
+        // No .ignore file found - cache null result for all directories
+        var nullEntry = new IgnoreFileCacheEntry(null);
+        foreach (var dir in checkedDirs)
+        {
+            _directoryCache.AddOrUpdate(dir, nullEntry);
+        }
+
+        return null;
+    }
+
+    private ParsedIgnoreCacheEntry? GetParsedRules(string ignoreFilePath)
     {
-        ignoreFile = FileSystemHelper.ResolveLinkTarget(ignoreFile, returnFinalTarget: true) ?? ignoreFile;
-        return ignoreFile.Exists
-            ? File.ReadAllText(ignoreFile.FullName)
-            : string.Empty;
+        FileInfo fileInfo;
+        try
+        {
+            fileInfo = new FileInfo(ignoreFilePath);
+            if (!fileInfo.Exists)
+            {
+                _rulesCache.TryRemove(ignoreFilePath, out _);
+                return null;
+            }
+        }
+        catch
+        {
+            _rulesCache.TryRemove(ignoreFilePath, out _);
+            return null;
+        }
+
+        var lastModified = fileInfo.LastWriteTimeUtc;
+        var fileLength = fileInfo.Length;
+
+        // Check cache
+        if (_rulesCache.TryGet(ignoreFilePath, out var cached))
+        {
+            if (cached.FileLastModified == lastModified && cached.FileLength == fileLength)
+            {
+                return cached;
+            }
+
+            // Stale - need to reparse
+            _rulesCache.TryRemove(ignoreFilePath, out _);
+        }
+
+        // Parse the file
+        var parsedEntry = ParseIgnoreFile(fileInfo, lastModified, fileLength);
+        _rulesCache.AddOrUpdate(ignoreFilePath, parsedEntry);
+        return parsedEntry;
+    }
+
+    private static ParsedIgnoreCacheEntry ParseIgnoreFile(FileInfo ignoreFile, DateTime lastModified, long fileLength)
+    {
+        if (ignoreFile.LinkTarget is null && fileLength == 0)
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        // Resolve symlinks
+        var resolvedFile = FileSystemHelper.ResolveLinkTarget(ignoreFile, returnFinalTarget: true) ?? ignoreFile;
+        if (!resolvedFile.Exists)
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        var content = File.ReadAllText(resolvedFile.FullName);
+        if (string.IsNullOrWhiteSpace(content))
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        var rules = content.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var ignore = new Ignore.Ignore();
+        var validRulesAdded = 0;
+
+        foreach (var rule in rules)
+        {
+            try
+            {
+                ignore.Add(rule);
+                validRulesAdded++;
+            }
+            catch (RegexParseException)
+            {
+                // Ignore invalid patterns
+            }
+        }
+
+        // No valid rules means treat as empty (ignore all)
+        return new ParsedIgnoreCacheEntry
+        {
+            Rules = ignore,
+            FileLastModified = lastModified,
+            FileLength = fileLength,
+            IsEmpty = validRulesAdded == 0
+        };
+    }
+
+    private static string GetPathToCheck(string path, bool isDirectory)
+    {
+        // Normalize Windows paths
+        var pathToCheck = IsWindows ? path.NormalizePath('/') : path;
+
+        // Add trailing slash for directories to match "folder/"
+        if (isDirectory)
+        {
+            pathToCheck = string.Concat(pathToCheck.AsSpan().TrimEnd('/'), "/");
+        }
+
+        return pathToCheck;
+    }
+
+    private readonly record struct IgnoreFileCacheEntry(string? IgnoreFilePath);
+
+    private sealed class ParsedIgnoreCacheEntry
+    {
+        public required Ignore.Ignore Rules { get; init; }
+
+        public required DateTime FileLastModified { get; init; }
+
+        public required long FileLength { get; init; }
+
+        public required bool IsEmpty { get; init; }
     }
 }
diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 2bcb10e9e1..46facf881b 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -84,6 +84,7 @@ namespace Emby.Server.Implementations.Library
         private readonly ExtraResolver _extraResolver;
         private readonly IPathManager _pathManager;
         private readonly FastConcurrentLru<Guid, BaseItem> _cache;
+        private readonly DotIgnoreIgnoreRule _dotIgnoreIgnoreRule;
 
         /// <summary>
         /// The _root folder sync lock.
@@ -125,6 +126,7 @@ namespace Emby.Server.Implementations.Library
         /// <param name="directoryService">The directory service.</param>
         /// <param name="peopleRepository">The people repository.</param>
         /// <param name="pathManager">The path manager.</param>
+        /// <param name="dotIgnoreIgnoreRule">The .ignore rule handler.</param>
         public LibraryManager(
             IServerApplicationHost appHost,
             ILoggerFactory loggerFactory,
@@ -146,7 +148,8 @@ namespace Emby.Server.Implementations.Library
             NamingOptions namingOptions,
             IDirectoryService directoryService,
             IPeopleRepository peopleRepository,
-            IPathManager pathManager)
+            IPathManager pathManager,
+            DotIgnoreIgnoreRule dotIgnoreIgnoreRule)
         {
             _appHost = appHost;
             _logger = loggerFactory.CreateLogger<LibraryManager>();
@@ -171,6 +174,7 @@ namespace Emby.Server.Implementations.Library
             _namingOptions = namingOptions;
             _peopleRepository = peopleRepository;
             _pathManager = pathManager;
+            _dotIgnoreIgnoreRule = dotIgnoreIgnoreRule;
             _extraResolver = new ExtraResolver(loggerFactory.CreateLogger<ExtraResolver>(), namingOptions, directoryService);
 
             _configurationManager.ConfigurationUpdated += ConfigurationUpdated;
@@ -1303,6 +1307,7 @@ namespace Emby.Server.Implementations.Library
         public async Task ValidateMediaLibraryInternal(IProgress<double> progress, CancellationToken cancellationToken)
         {
             IsScanRunning = true;
+            ClearIgnoreRuleCache();
             LibraryMonitor.Stop();
 
             try
@@ -1311,6 +1316,7 @@ namespace Emby.Server.Implementations.Library
             }
             finally
             {
+                ClearIgnoreRuleCache();
                 LibraryMonitor.Start();
                 IsScanRunning = false;
             }
@@ -1318,6 +1324,7 @@ namespace Emby.Server.Implementations.Library
 
         public async Task ValidateTopLibraryFolders(CancellationToken cancellationToken, bool removeRoot = false)
         {
+            ClearIgnoreRuleCache();
             RootFolder.Children = null;
             await RootFolder.RefreshMetadata(cancellationToken).ConfigureAwait(false);
 
@@ -1360,6 +1367,14 @@ namespace Emby.Server.Implementations.Library
             {
                 _persistenceService.DeleteItem(toDelete.ToArray());
             }
+
+            ClearIgnoreRuleCache();
+        }
+
+        /// <inheritdoc />
+        public void ClearIgnoreRuleCache()
+        {
+            _dotIgnoreIgnoreRule.ClearDirectoryCache();
         }
 
         private async Task PerformLibraryValidation(IProgress<double> progress, CancellationToken cancellationToken)
@@ -3161,7 +3176,7 @@ namespace Emby.Server.Implementations.Library
         public IEnumerable<BaseItem> FindExtras(BaseItem owner, IReadOnlyList<FileSystemMetadata> fileSystemChildren, IDirectoryService directoryService)
         {
             // Apply .ignore rules
-            var filtered = fileSystemChildren.Where(c => !DotIgnoreIgnoreRule.IsIgnored(c, owner)).ToList();
+            var filtered = fileSystemChildren.Where(c => !_dotIgnoreIgnoreRule.ShouldIgnore(c, owner)).ToList();
             var isFolder = owner.IsFolder || (owner is Video video && (video.VideoType == VideoType.BluRay || video.VideoType == VideoType.Dvd));
             var ownerVideoInfo = VideoResolver.Resolve(owner.Path, isFolder, _namingOptions, libraryRoot: owner.ContainingFolderPath);
             if (ownerVideoInfo is null)
diff --git a/Jellyfin.Api/Controllers/LibraryStructureController.cs b/Jellyfin.Api/Controllers/LibraryStructureController.cs
index 8136dec177..e46795554b 100644
--- a/Jellyfin.Api/Controllers/LibraryStructureController.cs
+++ b/Jellyfin.Api/Controllers/LibraryStructureController.cs
@@ -189,6 +189,7 @@ public class LibraryStructureController : BaseJellyfinApiController
                     var newLib = _libraryManager.GetUserRootFolder().Children.FirstOrDefault(f => f.Path.Equals(newPath, StringComparison.OrdinalIgnoreCase));
                     if (newLib is CollectionFolder folder)
                     {
+                        _libraryManager.ClearIgnoreRuleCache();
                         foreach (var child in folder.GetPhysicalFolders())
                         {
                             await child.RefreshMetadata(CancellationToken.None).ConfigureAwait(false);
@@ -197,9 +198,12 @@ public class LibraryStructureController : BaseJellyfinApiController
                     }
                     else
                     {
+                        _libraryManager.ClearIgnoreRuleCache();
                         // We don't know if this one can be validated individually, trigger a new validation
                         await _libraryManager.ValidateMediaLibrary(new Progress<double>(), CancellationToken.None).ConfigureAwait(false);
                     }
+
+                    _libraryManager.ClearIgnoreRuleCache();
                 }
                 else
                 {
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index 5c391098d3..349c790a81 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -177,6 +177,13 @@ namespace MediaBrowser.Controller.Library
         /// <returns>Task.</returns>
         Task ValidateTopLibraryFolders(CancellationToken cancellationToken, bool removeRoot = false);
 
+        /// <summary>
+        /// Clears the cached ignore rule directory lookups.
+        /// Call this before triggering a library scan or item refresh to ensure
+        /// any changes to .ignore files are picked up.
+        /// </summary>
+        void ClearIgnoreRuleCache();
+
         Task UpdateImagesAsync(BaseItem item, bool forceUpdate = false);
 
         /// <summary>
diff --git a/MediaBrowser.Providers/Manager/ProviderManager.cs b/MediaBrowser.Providers/Manager/ProviderManager.cs
index d57e85c62f..65edcb2a92 100644
--- a/MediaBrowser.Providers/Manager/ProviderManager.cs
+++ b/MediaBrowser.Providers/Manager/ProviderManager.cs
@@ -1133,6 +1133,7 @@ namespace MediaBrowser.Providers.Manager
 
             var cancellationToken = _disposeCancellationTokenSource.Token;
 
+            libraryManager.ClearIgnoreRuleCache();
             while (_refreshQueue.TryDequeue(out var refreshItem, out _))
             {
                 if (_disposed)
@@ -1167,6 +1168,7 @@ namespace MediaBrowser.Providers.Manager
             lock (_refreshQueueLock)
             {
                 _isProcessingRefreshQueue = false;
+                libraryManager.ClearIgnoreRuleCache();
             }
         }
 
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
index a7bbef7ed4..03c0b4af39 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
@@ -1,4 +1,9 @@
+using System;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
 using Emby.Server.Implementations.Library;
+using MediaBrowser.Model.IO;
 using Xunit;
 
 namespace Jellyfin.Server.Implementations.Tests.Library;
@@ -78,4 +83,391 @@ public class DotIgnoreIgnoreRuleTest
         // Without normalization, Windows paths with backslashes won't match patterns expecting forward slashes
         Assert.False(DotIgnoreIgnoreRule.CheckIgnoreRules(path, _rule1, isDirectory: false, normalizePath: false));
     }
+
+    [Fact]
+    public void CacheHit_RepeatedCallsDoNotRereadFiles()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var subDir = Path.Combine(tempDir, "subdir");
+        Directory.CreateDirectory(subDir);
+
+        try
+        {
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, "*.tmp");
+
+            var rule = new DotIgnoreIgnoreRule();
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(subDir, "test.tmp"),
+                IsDirectory = false
+            };
+
+            // First call - should cache
+            var result1 = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result1);
+
+            // Second call - should use cache
+            var result2 = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result2);
+
+            // Third call with different file in same directory - should use cache
+            var fileInfo2 = new FileSystemMetadata
+            {
+                FullName = Path.Combine(subDir, "other.tmp"),
+                IsDirectory = false
+            };
+            var result3 = rule.ShouldIgnore(fileInfo2, null);
+            Assert.True(result3);
+
+            // Call with file that doesn't match pattern
+            var fileInfo3 = new FileSystemMetadata
+            {
+                FullName = Path.Combine(subDir, "other.txt"),
+                IsDirectory = false
+            };
+            var result4 = rule.ShouldIgnore(fileInfo3, null);
+            Assert.False(result4);
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void CacheInvalidation_ModifyIgnoreFile_Reparses()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+
+        try
+        {
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, "*.tmp");
+
+            var rule = new DotIgnoreIgnoreRule();
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(tempDir, "test.tmp"),
+                IsDirectory = false
+            };
+
+            // First call - should ignore .tmp files
+            var result1 = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result1);
+
+            // Modify the .ignore file to ignore .txt instead
+            // Wait a bit to ensure the file modification time changes
+            Thread.Sleep(50);
+            File.WriteAllText(ignoreFilePath, "*.txt");
+
+            // Now .tmp files should NOT be ignored
+            var result2 = rule.ShouldIgnore(fileInfo, null);
+            Assert.False(result2);
+
+            // And .txt files SHOULD be ignored
+            var txtFileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(tempDir, "test.txt"),
+                IsDirectory = false
+            };
+            var result3 = rule.ShouldIgnore(txtFileInfo, null);
+            Assert.True(result3);
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void EmptyIgnoreFile_IgnoresEverything()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+
+        try
+        {
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, string.Empty);
+
+            var rule = new DotIgnoreIgnoreRule();
+
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(tempDir, "anyfile.mkv"),
+                IsDirectory = false
+            };
+
+            // Empty .ignore file should ignore everything
+            var result = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result);
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void WhitespaceOnlyIgnoreFile_IgnoresEverything()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+
+        try
+        {
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, "   \n\t\n   ");
+
+            var rule = new DotIgnoreIgnoreRule();
+
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(tempDir, "anyfile.mkv"),
+                IsDirectory = false
+            };
+
+            // Whitespace-only .ignore file should ignore everything
+            var result = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result);
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void NoIgnoreFile_DoesNotIgnore()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+
+        try
+        {
+            var rule = new DotIgnoreIgnoreRule();
+
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(tempDir, "anyfile.mkv"),
+                IsDirectory = false
+            };
+
+            // No .ignore file means don't ignore
+            var result = rule.ShouldIgnore(fileInfo, null);
+            Assert.False(result);
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void ConcurrentAccess_ThreadSafe()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+
+        try
+        {
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, "*.tmp");
+
+            var rule = new DotIgnoreIgnoreRule();
+
+            // Run multiple parallel checks
+            Parallel.For(0, 100, i =>
+            {
+                var fileInfo = new FileSystemMetadata
+                {
+                    FullName = Path.Combine(tempDir, $"test{i}.tmp"),
+                    IsDirectory = false
+                };
+
+                var result = rule.ShouldIgnore(fileInfo, null);
+                Assert.True(result);
+            });
+
+            // Also test with non-matching files
+            Parallel.For(0, 100, i =>
+            {
+                var fileInfo = new FileSystemMetadata
+                {
+                    FullName = Path.Combine(tempDir, $"test{i}.txt"),
+                    IsDirectory = false
+                };
+
+                var result = rule.ShouldIgnore(fileInfo, null);
+                Assert.False(result);
+            });
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void ClearCache_ClearsAllCachedData()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+
+        try
+        {
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, "*.tmp");
+
+            var rule = new DotIgnoreIgnoreRule();
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(tempDir, "test.tmp"),
+                IsDirectory = false
+            };
+
+            // First call to populate cache
+            var result1 = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result1);
+
+            // Clear cache
+            rule.ClearDirectoryCache();
+
+            // Should still work (will re-populate cache)
+            var result2 = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result2);
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void IgnoreFileDeleted_HandlesGracefully()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+
+        try
+        {
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, "*.tmp");
+
+            var rule = new DotIgnoreIgnoreRule();
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(tempDir, "test.tmp"),
+                IsDirectory = false
+            };
+
+            // First call - should ignore
+            var result1 = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result1);
+
+            // Delete the .ignore file
+            File.Delete(ignoreFilePath);
+
+            // Should not ignore anymore (file deleted)
+            var result2 = rule.ShouldIgnore(fileInfo, null);
+            Assert.False(result2);
+        }
+        finally
+        {
+            if (Directory.Exists(tempDir))
+            {
+                Directory.Delete(tempDir, true);
+            }
+        }
+    }
+
+    [Fact]
+    public void ParentDirectoryIgnoreFile_AppliesToSubdirectories()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var subDir1 = Path.Combine(tempDir, "sub1");
+        var subDir2 = Path.Combine(tempDir, "sub1", "sub2");
+        Directory.CreateDirectory(subDir1);
+        Directory.CreateDirectory(subDir2);
+
+        try
+        {
+            // Put .ignore in root
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, "*.tmp");
+
+            var rule = new DotIgnoreIgnoreRule();
+
+            // Check file in sub2 - should find .ignore in parent
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(subDir2, "test.tmp"),
+                IsDirectory = false
+            };
+
+            var result = rule.ShouldIgnore(fileInfo, null);
+            Assert.True(result);
+
+            // Check file in sub1
+            var fileInfo2 = new FileSystemMetadata
+            {
+                FullName = Path.Combine(subDir1, "test.tmp"),
+                IsDirectory = false
+            };
+
+            var result2 = rule.ShouldIgnore(fileInfo2, null);
+            Assert.True(result2);
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
+
+    [Fact]
+    public void DirectoryMatching_TrailingSlashPattern()
+    {
+        var tempDir = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
+        Directory.CreateDirectory(tempDir);
+        var subDir = Path.Combine(tempDir, "videos");
+        Directory.CreateDirectory(subDir);
+
+        try
+        {
+            var ignoreFilePath = Path.Combine(tempDir, ".ignore");
+            File.WriteAllText(ignoreFilePath, "videos/");
+
+            var rule = new DotIgnoreIgnoreRule();
+
+            // Directory should be ignored
+            var dirInfo = new FileSystemMetadata
+            {
+                FullName = subDir,
+                IsDirectory = true
+            };
+
+            var result = rule.ShouldIgnore(dirInfo, null);
+            Assert.True(result);
+
+            // File named "videos" should NOT be ignored (pattern has trailing slash)
+            var fileInfo = new FileSystemMetadata
+            {
+                FullName = Path.Combine(tempDir, "videos"),
+                IsDirectory = false
+            };
+
+            // Note: The Ignore library behavior may vary here, this tests the actual behavior
+            var resultFile = rule.ShouldIgnore(fileInfo, null);
+            // The file named "videos" without trailing slash might or might not match depending on the library
+            // This test documents the actual behavior
+        }
+        finally
+        {
+            Directory.Delete(tempDir, true);
+        }
+    }
 }
-- 
cgit v1.2.3


From ec990be12af3856eea597ba7ebdd5dbfa5b01ace Mon Sep 17 00:00:00 2001
From: dkanada <dkanada@users.noreply.github.com>
Date: Mon, 4 May 2026 12:06:11 +0900
Subject: fix person TotalRecordCount when limit is applied

---
 .../Library/LibraryManager.cs                      | 46 ++++++++++++----------
 Jellyfin.Api/Controllers/PersonsController.cs      |  8 ++--
 .../Item/PeopleRepository.cs                       | 18 +++++++--
 MediaBrowser.Controller/Library/ILibraryManager.cs |  2 +-
 .../Persistence/IPeopleRepository.cs               |  8 ++--
 5 files changed, 51 insertions(+), 31 deletions(-)

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index eee87c4d8b..a7062914cf 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -34,14 +34,11 @@ using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.MediaEncoding;
-using MediaBrowser.Controller.MediaSegments;
 using MediaBrowser.Controller.Persistence;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Resolvers;
 using MediaBrowser.Controller.Sorting;
-using MediaBrowser.Controller.Trickplay;
 using MediaBrowser.Model.Configuration;
-using MediaBrowser.Model.Dlna;
 using MediaBrowser.Model.Drawing;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
@@ -2918,7 +2915,7 @@ namespace Emby.Server.Implementations.Library
 
         public IReadOnlyList<PersonInfo> GetPeople(InternalPeopleQuery query)
         {
-            return _peopleRepository.GetPeople(query);
+            return _peopleRepository.GetPeople(query).Items;
         }
 
         public IReadOnlyList<PersonInfo> GetPeople(BaseItem item)
@@ -2939,24 +2936,33 @@ namespace Emby.Server.Implementations.Library
             return [];
         }
 
-        public IReadOnlyList<Person> GetPeopleItems(InternalPeopleQuery query)
+        public QueryResult<BaseItem> GetPeopleItems(InternalPeopleQuery query)
         {
-            return _peopleRepository.GetPeopleNames(query)
-            .Select(i =>
-            {
-                try
+            var queryResult = _peopleRepository.GetPeople(query);
+            var baseItems = queryResult.Items.Select(i =>
                 {
-                    return GetPerson(i);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogError(ex, "Error getting person");
-                    return null;
-                }
-            })
-            .Where(i => i is not null)
-            .Where(i => query.User is null || i!.IsVisible(query.User))
-            .ToList()!; // null values are filtered out
+                    try
+                    {
+                        return GetPerson(i.Name);
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogError(ex, "error retrieving BaseItem for person: {0}", i.Name);
+                        return null;
+                    }
+                })
+                .Where(i => i is not null)
+                .Where(i => query.User is null || i!.IsVisible(query.User))
+                .OfType<BaseItem>()
+                .ToList()
+                .AsReadOnly();
+
+            return new QueryResult<BaseItem>
+            {
+                StartIndex = queryResult.StartIndex,
+                TotalRecordCount = queryResult.TotalRecordCount,
+                Items = baseItems,
+            };
         }
 
         public IReadOnlyList<string> GetPeopleNames(InternalPeopleQuery query)
diff --git a/Jellyfin.Api/Controllers/PersonsController.cs b/Jellyfin.Api/Controllers/PersonsController.cs
index 2b2afb0fe6..bc58580741 100644
--- a/Jellyfin.Api/Controllers/PersonsController.cs
+++ b/Jellyfin.Api/Controllers/PersonsController.cs
@@ -106,9 +106,11 @@ public class PersonsController : BaseJellyfinApiController
         });
 
         return new QueryResult<BaseItemDto>(
-            peopleItems
-            .Select(person => _dtoService.GetItemByNameDto(person, dtoOptions, null, user))
-            .ToArray());
+            peopleItems.StartIndex,
+            peopleItems.TotalRecordCount,
+            peopleItems.Items
+                .Select(person => _dtoService.GetItemByNameDto(person, dtoOptions, null, user))
+                .ToArray());
     }
 
     /// <summary>
diff --git a/Jellyfin.Server.Implementations/Item/PeopleRepository.cs b/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
index ad9953d1b6..576e786cb7 100644
--- a/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
@@ -1,14 +1,13 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
 using System.Linq;
 using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Entities.Libraries;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Querying;
 using Microsoft.EntityFrameworkCore;
 
 namespace Jellyfin.Server.Implementations.Item;
@@ -30,7 +29,7 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
     private readonly IDbContextFactory<JellyfinDbContext> _dbProvider = dbProvider;
 
     /// <inheritdoc/>
-    public IReadOnlyList<PersonInfo> GetPeople(InternalPeopleQuery filter)
+    public QueryResult<PersonInfo> GetPeople(InternalPeopleQuery filter)
     {
         using var context = _dbProvider.CreateDbContext();
         var dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter);
@@ -48,12 +47,23 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
             dbQuery = dbQuery.OrderBy(e => e.Name);
         }
 
+        var count = dbQuery.Count();
+        if (filter.StartIndex.HasValue && filter.StartIndex > 0)
+        {
+            dbQuery = dbQuery.Skip(filter.StartIndex.Value);
+        }
+
         if (filter.Limit > 0)
         {
             dbQuery = dbQuery.Take(filter.Limit);
         }
 
-        return dbQuery.AsEnumerable().Select(Map).ToArray();
+        return new QueryResult<PersonInfo>
+        {
+            StartIndex = filter.StartIndex ?? 0,
+            TotalRecordCount = count,
+            Items = dbQuery.AsEnumerable().Select(Map).ToArray(),
+        };
     }
 
     /// <inheritdoc/>
diff --git a/MediaBrowser.Controller/Library/ILibraryManager.cs b/MediaBrowser.Controller/Library/ILibraryManager.cs
index df1c98f3f7..a96667545e 100644
--- a/MediaBrowser.Controller/Library/ILibraryManager.cs
+++ b/MediaBrowser.Controller/Library/ILibraryManager.cs
@@ -514,7 +514,7 @@ namespace MediaBrowser.Controller.Library
         /// </summary>
         /// <param name="query">The query.</param>
         /// <returns>List&lt;Person&gt;.</returns>
-        IReadOnlyList<Person> GetPeopleItems(InternalPeopleQuery query);
+        QueryResult<BaseItem> GetPeopleItems(InternalPeopleQuery query);
 
         /// <summary>
         /// Updates the people.
diff --git a/MediaBrowser.Controller/Persistence/IPeopleRepository.cs b/MediaBrowser.Controller/Persistence/IPeopleRepository.cs
index 418289cb4c..a89f3ef9ee 100644
--- a/MediaBrowser.Controller/Persistence/IPeopleRepository.cs
+++ b/MediaBrowser.Controller/Persistence/IPeopleRepository.cs
@@ -1,13 +1,15 @@
 #nullable disable
 
-#pragma warning disable CS1591
-
 using System;
 using System.Collections.Generic;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Querying;
 
 namespace MediaBrowser.Controller.Persistence;
 
+/// <summary>
+/// Provides methods for accessing Peoples.
+/// </summary>
 public interface IPeopleRepository
 {
     /// <summary>
@@ -15,7 +17,7 @@ public interface IPeopleRepository
     /// </summary>
     /// <param name="filter">The query.</param>
     /// <returns>The list of people matching the filter.</returns>
-    IReadOnlyList<PersonInfo> GetPeople(InternalPeopleQuery filter);
+    QueryResult<PersonInfo> GetPeople(InternalPeopleQuery filter);
 
     /// <summary>
     /// Updates the people.
-- 
cgit v1.2.3


From fa65a392b0e754848caf94f08724ba19ec8bdd9f Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Mon, 4 May 2026 10:22:13 +0200
Subject: Fix Playlist and Boxset query and count perf

---
 .../Library/LibraryManager.cs                      |   21 +
 MediaBrowser.Controller/Entities/Folder.cs         |   82 +-
 MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs  |   32 +-
 .../ModelConfiguration/BaseItemConfiguration.cs    |    4 +
 ...075755_AddPartialIndexForItemCounts.Designer.cs | 1796 ++++++++++++++++++++
 .../20260504075755_AddPartialIndexForItemCounts.cs |   28 +
 .../Migrations/JellyfinDbModelSnapshot.cs          |    5 +-
 7 files changed, 1949 insertions(+), 19 deletions(-)
 create mode 100644 src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260504075755_AddPartialIndexForItemCounts.Designer.cs
 create mode 100644 src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260504075755_AddPartialIndexForItemCounts.cs

(limited to 'Emby.Server.Implementations/Library/LibraryManager.cs')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 2bcb10e9e1..2f62a6e442 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -30,11 +30,13 @@ using MediaBrowser.Controller.Drawing;
 using MediaBrowser.Controller.Dto;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.Movies;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.MediaEncoding;
 using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Controller.Playlists;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Resolvers;
 using MediaBrowser.Controller.Sorting;
@@ -1881,6 +1883,25 @@ namespace Emby.Server.Implementations.Library
                     query.TopParentIds = [Guid.NewGuid()];
                 }
             }
+            else if (parents.Count == 1 && parents.First() is Folder folder
+                && (folder is Playlist || folder is BoxSet)
+                && folder.LinkedChildren.Length > 0)
+            {
+                // Playlists and BoxSets store their contents in LinkedChildren and never
+                // populate AncestorIds for those items, so a recursive AncestorIds query
+                // would return zero rows. Resolve to the linked child IDs up front and
+                // route through the existing indexed ItemIds filter.
+                query.ItemIds = folder.LinkedChildren
+                    .Where(lc => lc.ItemId.HasValue && !lc.ItemId.Value.IsEmpty())
+                    .Select(lc => lc.ItemId!.Value)
+                    .ToArray();
+
+                // Empty linked-children should still return empty rather than scanning everything.
+                if (query.ItemIds.Length == 0)
+                {
+                    query.ItemIds = [Guid.NewGuid()];
+                }
+            }
             else
             {
                 // We need to be able to query from any arbitrary ancestor up the tree
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index 3b20dc85fe..5fa1213db3 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -1593,17 +1593,11 @@ namespace MediaBrowser.Controller.Entities
         /// <returns>IEnumerable{BaseItem}.</returns>
         public List<BaseItem> GetLinkedChildren()
         {
-            var linkedChildren = LinkedChildren;
-            var list = new List<BaseItem>(linkedChildren.Length);
-
-            foreach (var i in linkedChildren)
+            var resolved = ResolveLinkedChildren(LinkedChildren);
+            var list = new List<BaseItem>(resolved.Count);
+            foreach (var (_, item) in resolved)
             {
-                var child = GetLinkedChild(i);
-
-                if (child is not null)
-                {
-                    list.Add(child);
-                }
+                list.Add(item);
             }
 
             return list;
@@ -1704,12 +1698,74 @@ namespace MediaBrowser.Controller.Entities
         /// <returns>IEnumerable{BaseItem}.</returns>
         public IReadOnlyList<Tuple<LinkedChild, BaseItem>> GetLinkedChildrenInfos()
         {
-            return LinkedChildren
-                .Select(i => new Tuple<LinkedChild, BaseItem>(i, GetLinkedChild(i)))
-                .Where(i => i.Item2 is not null)
+            return ResolveLinkedChildren(LinkedChildren)
+                .Select(t => new Tuple<LinkedChild, BaseItem>(t.Info, t.Item))
                 .ToArray();
         }
 
+        /// <summary>
+        /// Resolves a list of <see cref="LinkedChild"/> entries to their <see cref="BaseItem"/> targets,
+        /// batching the database lookup across all entries with a known ItemId.
+        /// Entries without a usable ItemId fall back to the per-entry <see cref="BaseItem.GetLinkedChild"/>
+        /// path (legacy path-based resolution).
+        /// </summary>
+        /// <param name="linkedChildren">Linked children to resolve.</param>
+        /// <returns>Each input entry paired with its resolved item; entries that fail to resolve are dropped.</returns>
+        private List<(LinkedChild Info, BaseItem Item)> ResolveLinkedChildren(IReadOnlyList<LinkedChild> linkedChildren)
+        {
+            var resolved = new List<(LinkedChild Info, BaseItem Item)>(linkedChildren.Count);
+            if (linkedChildren.Count == 0)
+            {
+                return resolved;
+            }
+
+            var idsToBatch = new HashSet<Guid>();
+            foreach (var info in linkedChildren)
+            {
+                if (info.ItemId.HasValue && !info.ItemId.Value.IsEmpty())
+                {
+                    idsToBatch.Add(info.ItemId.Value);
+                }
+            }
+
+            Dictionary<Guid, BaseItem> byId = null;
+            if (idsToBatch.Count > 0)
+            {
+                var batched = LibraryManager.GetItemList(new InternalItemsQuery
+                {
+                    ItemIds = [.. idsToBatch]
+                });
+                byId = new Dictionary<Guid, BaseItem>(batched.Count);
+                foreach (var item in batched)
+                {
+                    byId[item.Id] = item;
+                }
+            }
+
+            foreach (var info in linkedChildren)
+            {
+                BaseItem item = null;
+                if (byId is not null && info.ItemId.HasValue && byId.TryGetValue(info.ItemId.Value, out var batchedItem))
+                {
+                    item = batchedItem;
+                }
+                else
+                {
+                    // ItemId is missing/empty or the batched query couldn't return the item
+                    // (e.g. it has been removed). Fall back to per-entry resolution, which also
+                    // handles legacy path-based linked children.
+                    item = GetLinkedChild(info);
+                }
+
+                if (item is not null)
+                {
+                    resolved.Add((info, item));
+                }
+            }
+
+            return resolved;
+        }
+
         protected override async Task<bool> RefreshedOwnedItems(MetadataRefreshOptions options, IReadOnlyList<FileSystemMetadata> fileSystemChildren, CancellationToken cancellationToken)
         {
             var changesFound = false;
diff --git a/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs b/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
index a065b68321..b0f51aec71 100644
--- a/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
+++ b/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
 using System.Linq;
@@ -6,7 +7,6 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Xml;
-using Jellyfin.Data.Enums;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
@@ -485,16 +485,38 @@ namespace MediaBrowser.LocalMetadata.Savers
                 return;
             }
 
+            // Batch-resolve all ItemIds to paths in a single query to avoid an N+1 round-trip per linked child
+            var idsToResolve = new HashSet<Guid>();
+            foreach (var link in linkedChildren)
+            {
+                if (link.ItemId.HasValue && !link.ItemId.Value.Equals(Guid.Empty))
+                {
+                    idsToResolve.Add(link.ItemId.Value);
+                }
+            }
+
+            Dictionary<Guid, string?>? pathById = null;
+            if (idsToResolve.Count > 0)
+            {
+                var batched = LibraryManager.GetItemList(new InternalItemsQuery
+                {
+                    ItemIds = [.. idsToResolve]
+                });
+                pathById = new Dictionary<Guid, string?>(batched.Count);
+                foreach (var batchedItem in batched)
+                {
+                    pathById[batchedItem.Id] = batchedItem.Path;
+                }
+            }
+
             await writer.WriteStartElementAsync(null, pluralNodeName, null).ConfigureAwait(false);
 
             foreach (var link in linkedChildren)
             {
-                // Resolve ItemId to get the item's path for XML portability
                 string? path = null;
-                if (link.ItemId.HasValue && !link.ItemId.Value.Equals(Guid.Empty))
+                if (pathById is not null && link.ItemId.HasValue && pathById.TryGetValue(link.ItemId.Value, out var resolvedPath))
                 {
-                    var linkedItem = LibraryManager.GetItemById(link.ItemId.Value);
-                    path = linkedItem?.Path;
+                    path = resolvedPath;
                 }
 
                 if (!string.IsNullOrWhiteSpace(path))
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/BaseItemConfiguration.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/BaseItemConfiguration.cs
index 7fe1836c42..8556fb7bb3 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/BaseItemConfiguration.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/BaseItemConfiguration.cs
@@ -73,6 +73,10 @@ public class BaseItemConfiguration : IEntityTypeConfiguration<BaseItemEntity>
         builder.HasIndex(e => e.SeasonId);
         builder.HasIndex(e => e.SeriesId);
 
+        // Items/Counts: SELECT Type, COUNT(*) GROUP BY Type filtered by TopParentId.
+        builder.HasIndex(e => new { e.TopParentId, e.Type, e.IsVirtualItem })
+            .HasFilter("\"PrimaryVersionId\" IS NULL AND (\"OwnerId\" IS NULL OR \"ExtraType\" IS NOT NULL)");
+
         builder.HasData(new BaseItemEntity()
         {
             Id = Guid.Parse("00000000-0000-0000-0000-000000000001"),
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260504075755_AddPartialIndexForItemCounts.Designer.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260504075755_AddPartialIndexForItemCounts.Designer.cs
new file mode 100644
index 0000000000..23ab2a4674
--- /dev/null
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260504075755_AddPartialIndexForItemCounts.Designer.cs
@@ -0,0 +1,1796 @@
+// <auto-generated />
+using System;
+using Jellyfin.Database.Implementations;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+#nullable disable
+
+namespace Jellyfin.Database.Providers.Sqlite.Migrations
+{
+    [DbContext(typeof(JellyfinDbContext))]
+    [Migration("20260504075755_AddPartialIndexForItemCounts")]
+    partial class AddPartialIndexForItemCounts
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.7");
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DayOfWeek")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double>("EndHour")
+                        .HasColumnType("REAL");
+
+                    b.Property<double>("StartHour")
+                        .HasColumnType("REAL");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AccessSchedules");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ActivityLog", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ItemId")
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("LogSeverity")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Overview")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ShortOverview")
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DateCreated");
+
+                    b.ToTable("ActivityLogs");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AncestorId", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ParentItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "ParentItemId");
+
+                    b.HasIndex("ParentItemId");
+
+                    b.ToTable("AncestorIds");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AttachmentStreamInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Index")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Filename")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("MimeType")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "Index");
+
+                    b.ToTable("AttachmentStreamInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Album")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AlbumArtists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Artists")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Audio")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("ChannelId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CleanName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("CommunityRating")
+                        .HasColumnType("REAL");
+
+                    b.Property<float?>("CriticRating")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("CustomRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastMediaAdded")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastRefreshed")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateLastSaved")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("EndDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("EpisodeTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalSeriesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ExternalServiceId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ExtraType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ForcedSortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Genres")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("IndexNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("InheritedParentalRatingSubValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("InheritedParentalRatingValue")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsFolder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsInMixedFolder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsLocked")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsMovie")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsRepeat")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsSeries")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsVirtualItem")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<float?>("LUFS")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("MediaType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("NormalizationGain")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("OfficialRating")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("OriginalTitle")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Overview")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("OwnerId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ParentIndexNumber")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredMetadataCountryCode")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PreferredMetadataLanguage")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("PremiereDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PresentationUniqueKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("PrimaryVersionId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProductionLocations")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ProductionYear")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long?>("RunTimeTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("SeasonId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeasonName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("SeriesId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SeriesPresentationUniqueKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ShowId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long?>("Size")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("StartDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Studios")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tagline")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Tags")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("TopParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("TotalBitrate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Type")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UnratedType")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name");
+
+                    b.HasIndex("OwnerId");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("Path");
+
+                    b.HasIndex("PresentationUniqueKey");
+
+                    b.HasIndex("SeasonId");
+
+                    b.HasIndex("SeriesId");
+
+                    b.HasIndex("SeriesName");
+
+                    b.HasIndex("ExtraType", "OwnerId");
+
+                    b.HasIndex("TopParentId", "Id");
+
+                    b.HasIndex("Type", "CleanName");
+
+                    b.HasIndex("TopParentId", "Type", "IsVirtualItem")
+                        .HasFilter("\"PrimaryVersionId\" IS NULL AND (\"OwnerId\" IS NULL OR \"ExtraType\" IS NOT NULL)");
+
+                    b.HasIndex("Type", "TopParentId", "Id");
+
+                    b.HasIndex("Type", "TopParentId", "PresentationUniqueKey");
+
+                    b.HasIndex("Type", "TopParentId", "SortName");
+
+                    b.HasIndex("Type", "TopParentId", "StartDate");
+
+                    b.HasIndex("MediaType", "TopParentId", "IsVirtualItem", "PresentationUniqueKey");
+
+                    b.HasIndex("TopParentId", "IsFolder", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("TopParentId", "MediaType", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("TopParentId", "Type", "IsVirtualItem", "DateCreated");
+
+                    b.HasIndex("Type", "SeriesPresentationUniqueKey", "IsFolder", "IsVirtualItem");
+
+                    b.HasIndex("Type", "SeriesPresentationUniqueKey", "ParentIndexNumber", "IndexNumber");
+
+                    b.HasIndex("Type", "SeriesPresentationUniqueKey", "PresentationUniqueKey", "SortName");
+
+                    b.HasIndex("IsFolder", "TopParentId", "IsVirtualItem", "PresentationUniqueKey", "DateCreated");
+
+                    b.HasIndex("Type", "TopParentId", "IsVirtualItem", "PresentationUniqueKey", "DateCreated");
+
+                    b.ToTable("BaseItems");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+
+                    b.HasData(
+                        new
+                        {
+                            Id = new Guid("00000000-0000-0000-0000-000000000001"),
+                            IsFolder = false,
+                            IsInMixedFolder = false,
+                            IsLocked = false,
+                            IsMovie = false,
+                            IsRepeat = false,
+                            IsSeries = false,
+                            IsVirtualItem = false,
+                            Name = "This is a placeholder item for UserData that has been detached from its original item",
+                            Type = "PLACEHOLDER"
+                        });
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemImageInfo", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<byte[]>("Blurhash")
+                        .HasColumnType("BLOB");
+
+                    b.Property<DateTime?>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ImageType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ItemId", "ImageType");
+
+                    b.ToTable("BaseItemImageInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemMetadataField", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("BaseItemMetadataFields");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemProvider", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ProviderValue")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemId", "ProviderId");
+
+                    b.HasIndex("ProviderId", "ItemId", "ProviderValue");
+
+                    b.ToTable("BaseItemProviders");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemTrailerType", b =>
+                {
+                    b.Property<int>("Id")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("BaseItemTrailerTypes");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Chapter", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChapterIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("ImageDateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ImagePath")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("StartPositionTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "ChapterIndex");
+
+                    b.ToTable("Chapters");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.CustomItemDisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Key")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "ItemId", "Client", "Key")
+                        .IsUnique();
+
+                    b.ToTable("CustomItemDisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ChromecastVersion")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DashboardTheme")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("EnableNextVideoInfoOverlay")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("IndexBy")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ScrollDirection")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowBackdrop")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("ShowSidebar")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SkipBackwardLength")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SkipForwardLength")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TvHome")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "ItemId", "Client")
+                        .IsUnique();
+
+                    b.ToTable("DisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.HomeSection", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("DisplayPreferencesId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Order")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DisplayPreferencesId");
+
+                    b.ToTable("HomeSection");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ImageInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId")
+                        .IsUnique();
+
+                    b.ToTable("ImageInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemDisplayPreferences", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Client")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("IndexBy")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("RememberIndexing")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberSorting")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SortBy")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ViewType")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("ItemDisplayPreferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValue", b =>
+                {
+                    b.Property<Guid>("ItemValueId")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CleanValue")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemValueId");
+
+                    b.HasIndex("Type", "CleanValue");
+
+                    b.HasIndex("Type", "Value")
+                        .IsUnique();
+
+                    b.ToTable("ItemValues");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValueMap", b =>
+                {
+                    b.Property<Guid>("ItemValueId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("ItemValueId", "ItemId");
+
+                    b.HasIndex("ItemId");
+
+                    b.ToTable("ItemValuesMap");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.KeyframeData", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.PrimitiveCollection<string>("KeyframeTicks")
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("TotalDuration")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId");
+
+                    b.ToTable("KeyframeData");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.LinkedChildEntity", b =>
+                {
+                    b.Property<Guid>("ParentId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("ChildId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChildType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ParentId", "ChildId");
+
+                    b.HasIndex("ChildId", "ChildType");
+
+                    b.HasIndex("ParentId", "ChildType");
+
+                    b.HasIndex("ParentId", "SortOrder");
+
+                    b.ToTable("LinkedChildren", (string)null);
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaSegment", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("EndTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("SegmentProviderId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<long>("StartTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MediaSegments");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaStreamInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("StreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AspectRatio")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("AverageFrameRate")
+                        .HasColumnType("REAL");
+
+                    b.Property<int?>("BitDepth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("BitRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("BlPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("ChannelLayout")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Channels")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Codec")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTag")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CodecTimeBase")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorPrimaries")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorSpace")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("ColorTransfer")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Comment")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("DvBlSignalCompatibilityId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvLevel")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvProfile")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvVersionMajor")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("DvVersionMinor")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("ElPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("Hdr10PlusPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsAnamorphic")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsAvc")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsDefault")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsExternal")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsForced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsHearingImpaired")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool?>("IsInterlaced")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("KeyFrames")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Language")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("Level")
+                        .HasColumnType("REAL");
+
+                    b.Property<string>("NalLengthSize")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PixelFormat")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Profile")
+                        .HasColumnType("TEXT");
+
+                    b.Property<float?>("RealFrameRate")
+                        .HasColumnType("REAL");
+
+                    b.Property<int?>("RefFrames")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("Rotation")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RpuPresentFlag")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SampleRate")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("StreamType")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("TimeBase")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "StreamIndex");
+
+                    b.ToTable("MediaStreamInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.People", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PersonType")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Name");
+
+                    b.ToTable("Peoples");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.PeopleBaseItemMap", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("PeopleId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Role")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("ListOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "PeopleId", "Role");
+
+                    b.HasIndex("PeopleId");
+
+                    b.HasIndex("ItemId", "ListOrder");
+
+                    b.HasIndex("ItemId", "SortOrder");
+
+                    b.ToTable("PeopleBaseItemMap");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Permission", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("Permission_Permissions_Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Value")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "Kind")
+                        .IsUnique()
+                        .HasFilter("[UserId] IS NOT NULL");
+
+                    b.ToTable("Permissions");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Preference", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Kind")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("Preference_Preferences_Guid")
+                        .HasColumnType("TEXT");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid?>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Value")
+                        .IsRequired()
+                        .HasMaxLength(65535)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "Kind")
+                        .IsUnique()
+                        .HasFilter("[UserId] IS NOT NULL");
+
+                    b.ToTable("Preferences");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.ApiKey", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateLastActivity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccessToken")
+                        .IsUnique();
+
+                    b.ToTable("ApiKeys");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.Device", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("AccessToken")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AppName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AppVersion")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateLastActivity")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AccessToken", "DateLastActivity");
+
+                    b.HasIndex("DeviceId", "DateLastActivity");
+
+                    b.HasIndex("UserId", "DeviceId");
+
+                    b.ToTable("Devices");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.DeviceOptions", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("CustomName")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("DeviceId")
+                        .IsRequired()
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeviceId")
+                        .IsUnique();
+
+                    b.ToTable("DeviceOptions");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.TrickplayInfo", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("Width")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Bandwidth")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Height")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Interval")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("ThumbnailCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TileHeight")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("TileWidth")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "Width");
+
+                    b.ToTable("TrickplayInfos");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.User", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AudioLanguagePreference")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("AuthenticationProviderId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CastReceiverId")
+                        .HasMaxLength(32)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("DisplayCollectionsView")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("DisplayMissingEpisodes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableAutoLogin")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableLocalPassword")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableNextEpisodeAutoPlay")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("EnableUserPreferenceAccess")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("HidePlayedInLatest")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("InternalId")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("InvalidLoginAttemptCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastActivityDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime?>("LastLoginDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("LoginAttemptsBeforeLockout")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxActiveSessions")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MaxParentalRatingScore")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("MaxParentalRatingSubScore")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("MustUpdatePassword")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Password")
+                        .HasMaxLength(65535)
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("PasswordResetProviderId")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("PlayDefaultAudioTrack")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberAudioSelections")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("RememberSubtitleSelections")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int?>("RemoteClientBitrateLimit")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<uint>("RowVersion")
+                        .IsConcurrencyToken()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("SubtitleLanguagePreference")
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("SubtitleMode")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("SyncPlayAccess")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("Username")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Username")
+                        .IsUnique();
+
+                    b.ToTable("Users");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.UserData", b =>
+                {
+                    b.Property<Guid>("ItemId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<Guid>("UserId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("CustomDataKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("AudioStreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("IsFavorite")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime?>("LastPlayedDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool?>("Likes")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PlayCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<long>("PlaybackPositionTicks")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Played")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<double?>("Rating")
+                        .HasColumnType("REAL");
+
+                    b.Property<DateTime?>("RetentionDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int?>("SubtitleStreamIndex")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ItemId", "UserId", "CustomDataKey");
+
+                    b.HasIndex("ItemId", "UserId", "IsFavorite");
+
+                    b.HasIndex("ItemId", "UserId", "LastPlayedDate");
+
+                    b.HasIndex("ItemId", "UserId", "PlaybackPositionTicks");
+
+                    b.HasIndex("ItemId", "UserId", "Played");
+
+                    b.HasIndex("UserId", "IsFavorite", "ItemId");
+
+                    b.HasIndex("UserId", "ItemId", "LastPlayedDate");
+
+                    b.HasIndex("UserId", "Played", "ItemId");
+
+                    b.ToTable("UserData");
+
+                    b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("AccessSchedules")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AncestorId", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Parents")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "ParentItem")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("ParentItem");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AttachmentStreamInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Owner")
+                        .WithMany("Extras")
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.NoAction);
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "DirectParent")
+                        .WithMany("DirectChildren")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.Cascade);
+
+                    b.Navigation("DirectParent");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemImageInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Images")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemMetadataField", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("LockedFields")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemProvider", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Provider")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemTrailerType", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("TrailerTypes")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Chapter", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Chapters")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("DisplayPreferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.HomeSection", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.DisplayPreferences", null)
+                        .WithMany("HomeSections")
+                        .HasForeignKey("DisplayPreferencesId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ImageInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithOne("ProfileImage")
+                        .HasForeignKey("Jellyfin.Database.Implementations.Entities.ImageInfo", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemDisplayPreferences", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("ItemDisplayPreferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValueMap", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("ItemValues")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.ItemValue", "ItemValue")
+                        .WithMany("BaseItemsMap")
+                        .HasForeignKey("ItemValueId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("ItemValue");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.KeyframeData", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany()
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.LinkedChildEntity", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Child")
+                        .WithMany("LinkedChildOfEntities")
+                        .HasForeignKey("ChildId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Parent")
+                        .WithMany("LinkedChildEntities")
+                        .HasForeignKey("ParentId")
+                        .OnDelete(DeleteBehavior.NoAction)
+                        .IsRequired();
+
+                    b.Navigation("Child");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.MediaStreamInfo", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("MediaStreams")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.PeopleBaseItemMap", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("Peoples")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.People", "People")
+                        .WithMany("BaseItems")
+                        .HasForeignKey("PeopleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("People");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Permission", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("Permissions")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Preference", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", null)
+                        .WithMany("Preferences")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade);
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.Security.Device", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.UserData", b =>
+                {
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.BaseItemEntity", "Item")
+                        .WithMany("UserData")
+                        .HasForeignKey("ItemId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Jellyfin.Database.Implementations.Entities.User", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Item");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.BaseItemEntity", b =>
+                {
+                    b.Navigation("Chapters");
+
+                    b.Navigation("Children");
+
+                    b.Navigation("DirectChildren");
+
+                    b.Navigation("Extras");
+
+                    b.Navigation("Images");
+
+                    b.Navigation("ItemValues");
+
+                    b.Navigation("LinkedChildEntities");
+
+                    b.Navigation("LinkedChildOfEntities");
+
+                    b.Navigation("LockedFields");
+
+                    b.Navigation("MediaStreams");
+
+                    b.Navigation("Parents");
+
+                    b.Navigation("Peoples");
+
+                    b.Navigation("Provider");
+
+                    b.Navigation("TrailerTypes");
+
+                    b.Navigation("UserData");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.DisplayPreferences", b =>
+                {
+                    b.Navigation("HomeSections");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.ItemValue", b =>
+                {
+                    b.Navigation("BaseItemsMap");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.People", b =>
+                {
+                    b.Navigation("BaseItems");
+                });
+
+            modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.User", b =>
+                {
+                    b.Navigation("AccessSchedules");
+
+                    b.Navigation("DisplayPreferences");
+
+                    b.Navigation("ItemDisplayPreferences");
+
+                    b.Navigation("Permissions");
+
+                    b.Navigation("Preferences");
+
+                    b.Navigation("ProfileImage");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260504075755_AddPartialIndexForItemCounts.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260504075755_AddPartialIndexForItemCounts.cs
new file mode 100644
index 0000000000..e1f62c12fb
--- /dev/null
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260504075755_AddPartialIndexForItemCounts.cs
@@ -0,0 +1,28 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Jellyfin.Database.Providers.Sqlite.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPartialIndexForItemCounts : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateIndex(
+                name: "IX_BaseItems_TopParentId_Type_IsVirtualItem",
+                table: "BaseItems",
+                columns: new[] { "TopParentId", "Type", "IsVirtualItem" },
+                filter: "\"PrimaryVersionId\" IS NULL AND (\"OwnerId\" IS NULL OR \"ExtraType\" IS NOT NULL)");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropIndex(
+                name: "IX_BaseItems_TopParentId_Type_IsVirtualItem",
+                table: "BaseItems");
+        }
+    }
+}
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
index d67e3a2149..2c74d47edc 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/JellyfinDbModelSnapshot.cs
@@ -15,7 +15,7 @@ namespace Jellyfin.Server.Implementations.Migrations
         protected override void BuildModel(ModelBuilder modelBuilder)
         {
 #pragma warning disable 612, 618
-            modelBuilder.HasAnnotation("ProductVersion", "10.0.3");
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.7");
 
             modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
                 {
@@ -382,6 +382,9 @@ namespace Jellyfin.Server.Implementations.Migrations
 
                     b.HasIndex("Type", "CleanName");
 
+                    b.HasIndex("TopParentId", "Type", "IsVirtualItem")
+                        .HasFilter("\"PrimaryVersionId\" IS NULL AND (\"OwnerId\" IS NULL OR \"ExtraType\" IS NOT NULL)");
+
                     b.HasIndex("Type", "TopParentId", "Id");
 
                     b.HasIndex("Type", "TopParentId", "PresentationUniqueKey");
-- 
cgit v1.2.3