From 7939f3b009e830e38a3f37455418011043429ee3 Mon Sep 17 00:00:00 2001
From: TheMelmacian <76712303+TheMelmacian@users.noreply.github.com>
Date: Mon, 25 May 2026 23:40:40 +0200
Subject: only fetch language codes for the requested library when generating
 filter values

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

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index cc85f09d23..f075d2f649 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -3862,5 +3862,17 @@ namespace Emby.Server.Implementations.Library
         {
             return _mediaStreamRepository.GetMediaStreamLanguages(mediaStreamType);
         }
+
+        /// <inheritdoc />
+        public IReadOnlyList<string> GetMediaStreamLanguages(MediaStreamType mediaStreamType, InternalItemsQuery query)
+        {
+            if (query.User is not null)
+            {
+                AddUserToQuery(query, query.User);
+            }
+
+            SetTopParentOrAncestorIds(query);
+            return _itemRepository.GetMediaStreamLanguages(query, mediaStreamType);
+        }
     }
 }
-- 
cgit v1.2.3


From 5104497331c0519c551e1af6b3999f0da0d65058 Mon Sep 17 00:00:00 2001
From: David Federman <dfederm@microsoft.com>
Date: Tue, 2 Jun 2026 23:12:50 -0700
Subject: Reject unsafe plugin package names in installer

---
 .../Updates/InstallationManager.cs                 | 43 ++++++++++++++++++++++
 .../Updates/InstallationManagerTests.cs            | 24 ++++++++++++
 2 files changed, 67 insertions(+)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Updates/InstallationManager.cs b/Emby.Server.Implementations/Updates/InstallationManager.cs
index ef53e3b326..c8a2d98bf4 100644
--- a/Emby.Server.Implementations/Updates/InstallationManager.cs
+++ b/Emby.Server.Implementations/Updates/InstallationManager.cs
@@ -521,9 +521,27 @@ namespace Emby.Server.Implementations.Updates
                 return;
             }
 
+            if (!IsValidPackageDirectoryName(package.Name))
+            {
+                _logger.LogError("Refusing to install package with invalid name {PackageName}.", package.Name);
+                throw new InvalidDataException($"Plugin package name '{package.Name}' is not a valid directory name.");
+            }
+
             // Always override the passed-in target (which is a file) and figure it out again
             string targetDir = Path.Combine(_appPaths.PluginsPath, package.Name);
 
+            var pluginsRoot = Path.TrimEndingDirectorySeparator(Path.GetFullPath(_appPaths.PluginsPath));
+            var resolvedTarget = Path.GetFullPath(targetDir);
+            if (!resolvedTarget.StartsWith(pluginsRoot + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase))
+            {
+                _logger.LogError(
+                    "Refusing to install package {PackageName}: resolved target {Resolved} is outside plugins directory {Root}.",
+                    package.Name,
+                    resolvedTarget,
+                    pluginsRoot);
+                throw new InvalidDataException($"Plugin package name '{package.Name}' resolves outside the plugins directory.");
+            }
+
             using var response = await _httpClientFactory.CreateClient(NamedClient.Default)
                 .GetAsync(new Uri(package.SourceUrl), cancellationToken).ConfigureAwait(false);
             response.EnsureSuccessStatusCode();
@@ -572,6 +590,31 @@ namespace Emby.Server.Implementations.Updates
             _pluginManager.ImportPluginFrom(targetDir);
         }
 
+        private static bool IsValidPackageDirectoryName(string? name)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+            {
+                return false;
+            }
+
+            if (name.Equals(".", StringComparison.Ordinal) || name.Equals("..", StringComparison.Ordinal))
+            {
+                return false;
+            }
+
+            if (name.Contains('/', StringComparison.Ordinal) || name.Contains('\\', StringComparison.Ordinal))
+            {
+                return false;
+            }
+
+            if (name.AsSpan().IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)
+            {
+                return false;
+            }
+
+            return true;
+        }
+
         private async Task<bool> InstallPackageInternal(InstallationInfo package, CancellationToken cancellationToken)
         {
             LocalPlugin? plugin = _pluginManager.Plugins.FirstOrDefault(p => p.Id.Equals(package.Id) && p.Version.Equals(package.Version))
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Updates/InstallationManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Updates/InstallationManagerTests.cs
index 92e10c9f92..4a10b2f607 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Updates/InstallationManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Updates/InstallationManagerTests.cs
@@ -109,5 +109,29 @@ namespace Jellyfin.Server.Implementations.Tests.Updates
             var ex = await Record.ExceptionAsync(() => _installationManager.InstallPackage(packageInfo, CancellationToken.None));
             Assert.Null(ex);
         }
+
+        [Theory]
+        [InlineData("../evil")]
+        [InlineData("..\\evil")]
+        [InlineData("../../escape_attempt")]
+        [InlineData("..")]
+        [InlineData(".")]
+        [InlineData("")]
+        [InlineData("   ")]
+        [InlineData("foo/bar")]
+        [InlineData("foo\\bar")]
+        [InlineData("/absolute")]
+        [InlineData("foo\0bar")]
+        public async Task InstallPackage_InvalidName_ThrowsInvalidDataException(string name)
+        {
+            var packageInfo = new InstallationInfo()
+            {
+                Name = name,
+                SourceUrl = "https://repo.jellyfin.org/releases/plugin/empty/empty.zip",
+                Checksum = "11b5b2f1a9ebc4f66d6ef19018543361"
+            };
+
+            await Assert.ThrowsAsync<InvalidDataException>(() => _installationManager.InstallPackage(packageInfo, CancellationToken.None));
+        }
     }
 }
-- 
cgit v1.2.3


From 26a149a970ad1f88fbd6e1676a5098e4a63531fe Mon Sep 17 00:00:00 2001
From: David Federman <dfederm@microsoft.com>
Date: Wed, 3 Jun 2026 08:04:39 -0700
Subject: Address PR comment

---
 Emby.Server.Implementations/Updates/InstallationManager.cs | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Updates/InstallationManager.cs b/Emby.Server.Implementations/Updates/InstallationManager.cs
index c8a2d98bf4..110c388fbe 100644
--- a/Emby.Server.Implementations/Updates/InstallationManager.cs
+++ b/Emby.Server.Implementations/Updates/InstallationManager.cs
@@ -32,6 +32,8 @@ namespace Emby.Server.Implementations.Updates
     /// </summary>
     public class InstallationManager : IInstallationManager
     {
+        private static readonly char[] InvlidPackageNameChars = [.. Path.GetInvalidFileNameChars(), '/', '\\'];
+
         /// <summary>
         /// The logger.
         /// </summary>
@@ -602,12 +604,7 @@ namespace Emby.Server.Implementations.Updates
                 return false;
             }
 
-            if (name.Contains('/', StringComparison.Ordinal) || name.Contains('\\', StringComparison.Ordinal))
-            {
-                return false;
-            }
-
-            if (name.AsSpan().IndexOfAny(Path.GetInvalidFileNameChars()) >= 0)
+            if (name.AsSpan().IndexOfAny(InvlidPackageNameChars) >= 0)
             {
                 return false;
             }
-- 
cgit v1.2.3


From 0ed27bad65aa48c4c39c74493a90c3c81795d5ab Mon Sep 17 00:00:00 2001
From: David Federman <dfederm@microsoft.com>
Date: Sat, 6 Jun 2026 21:55:30 -0700
Subject: Address PR comment

---
 Emby.Server.Implementations/Updates/InstallationManager.cs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Updates/InstallationManager.cs b/Emby.Server.Implementations/Updates/InstallationManager.cs
index 110c388fbe..6a60f7f5f6 100644
--- a/Emby.Server.Implementations/Updates/InstallationManager.cs
+++ b/Emby.Server.Implementations/Updates/InstallationManager.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Buffers;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.IO;
@@ -32,7 +33,7 @@ namespace Emby.Server.Implementations.Updates
     /// </summary>
     public class InstallationManager : IInstallationManager
     {
-        private static readonly char[] InvlidPackageNameChars = [.. Path.GetInvalidFileNameChars(), '/', '\\'];
+        private static readonly SearchValues<char> InvalidPackageNameChars = SearchValues.Create([.. Path.GetInvalidFileNameChars(), '/', '\\']);
 
         /// <summary>
         /// The logger.
@@ -604,7 +605,7 @@ namespace Emby.Server.Implementations.Updates
                 return false;
             }
 
-            if (name.AsSpan().IndexOfAny(InvlidPackageNameChars) >= 0)
+            if (name.IndexOfAny(InvalidPackageNameChars) >= 0)
             {
                 return false;
             }
-- 
cgit v1.2.3


From c242533f4ecdbf1fb04c172751007aab89a8645e Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sun, 7 Jun 2026 22:37:34 +0200
Subject: Add version-aware playback tracking

---
 .../Library/UserDataManager.cs                     |  36 ++++
 .../Session/SessionManager.cs                      |  51 +++++-
 MediaBrowser.Controller/Entities/BaseItem.cs       |  33 ++--
 MediaBrowser.Controller/Entities/Video.cs          | 145 +++++++++++----
 .../Library/IUserDataManager.cs                    |   8 +
 .../Entities/BaseItemTests.cs                      | 204 +++++++++++++++++++++
 6 files changed, 430 insertions(+), 47 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index 1281f1587f..962dd6fda8 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -385,5 +385,41 @@ namespace Emby.Server.Implementations.Library
 
             return playedToCompletion;
         }
+
+        /// <inheritdoc />
+        public void ResetPlaybackStreamSelections(User user, BaseItem item)
+        {
+            ArgumentNullException.ThrowIfNull(user);
+            ArgumentNullException.ThrowIfNull(item);
+
+            using var dbContext = _repository.CreateDbContext();
+            var rows = dbContext.UserData
+                .Where(e => e.ItemId == item.Id && e.UserId == user.Id
+                            && (e.AudioStreamIndex != null || e.SubtitleStreamIndex != null))
+                .ToList();
+
+            if (rows.Count == 0)
+            {
+                return;
+            }
+
+            foreach (var row in rows)
+            {
+                row.AudioStreamIndex = null;
+                row.SubtitleStreamIndex = null;
+            }
+
+            dbContext.SaveChanges();
+
+            var cacheKey = GetCacheKey(user.InternalId, item.Id);
+            if (_cache.TryGet(cacheKey, out var cached))
+            {
+                cached.AudioStreamIndex = null;
+                cached.SubtitleStreamIndex = null;
+                _cache.AddOrUpdate(cacheKey, cached);
+            }
+
+            item.UserData = dbContext.UserData.Where(e => e.ItemId == item.Id).AsNoTracking().ToArray();
+        }
     }
 }
diff --git a/Emby.Server.Implementations/Session/SessionManager.cs b/Emby.Server.Implementations/Session/SessionManager.cs
index 18811ef3a9..6017b7cbf6 100644
--- a/Emby.Server.Implementations/Session/SessionManager.cs
+++ b/Emby.Server.Implementations/Session/SessionManager.cs
@@ -725,6 +725,31 @@ namespace Emby.Server.Implementations.Session
             return item;
         }
 
+        /// <summary>
+        /// Resolves the item whose user data (playback position, played status) should be updated
+        /// for a playback report. When an alternate version is played the client reports the displayed
+        /// item as <c>ItemId</c> and the played version as <c>MediaSourceId</c>.
+        /// </summary>
+        /// <param name="libraryItem">The now playing (displayed) item.</param>
+        /// <param name="mediaSourceId">The reported media source id.</param>
+        /// <returns>The item to track progress against.</returns>
+        private BaseItem GetProgressItem(BaseItem libraryItem, string mediaSourceId)
+        {
+            if (libraryItem is Video libraryVideo
+                && !string.IsNullOrEmpty(mediaSourceId)
+                && Guid.TryParse(mediaSourceId, out var mediaSourceItemId)
+                && !mediaSourceItemId.Equals(libraryVideo.Id))
+            {
+                var versionItem = libraryVideo.GetAlternateVersion(mediaSourceItemId);
+                if (versionItem is not null)
+                {
+                    return versionItem;
+                }
+            }
+
+            return libraryItem;
+        }
+
         /// <summary>
         /// Used to report that playback has started for an item.
         /// </summary>
@@ -756,9 +781,10 @@ namespace Emby.Server.Implementations.Session
 
             if (libraryItem is not null)
             {
+                var progressItem = GetProgressItem(libraryItem, info.MediaSourceId);
                 foreach (var user in users)
                 {
-                    OnPlaybackStart(user, libraryItem);
+                    OnPlaybackStart(user, progressItem);
                 }
             }
 
@@ -890,9 +916,10 @@ namespace Emby.Server.Implementations.Session
             // only update saved user data on actual check-ins, not automated ones
             if (libraryItem is not null && !isAutomated)
             {
+                var progressItem = GetProgressItem(libraryItem, info.MediaSourceId);
                 foreach (var user in users)
                 {
-                    OnPlaybackProgress(user, libraryItem, info);
+                    OnPlaybackProgress(user, progressItem, info);
                 }
             }
 
@@ -952,6 +979,17 @@ namespace Emby.Server.Implementations.Session
             if (changed)
             {
                 _userDataManager.SaveUserData(user, item, data, UserDataSaveReason.PlaybackProgress, CancellationToken.None);
+
+                if (data.Played == true && item is Video playedVideo)
+                {
+                    playedVideo.PropagatePlayedState(user, true);
+                }
+            }
+
+            if ((!user.RememberAudioSelections && data.AudioStreamIndex.HasValue)
+                || (!user.RememberSubtitleSelections && data.SubtitleStreamIndex.HasValue))
+            {
+                _userDataManager.ResetPlaybackStreamSelections(user, item);
             }
         }
 
@@ -1083,9 +1121,10 @@ namespace Emby.Server.Implementations.Session
 
             if (libraryItem is not null)
             {
+                var progressItem = GetProgressItem(libraryItem, info.MediaSourceId);
                 foreach (var user in users)
                 {
-                    playedToCompletion = OnPlaybackStopped(user, libraryItem, info.PositionTicks, info.Failed);
+                    playedToCompletion = OnPlaybackStopped(user, progressItem, info.PositionTicks, info.Failed);
                 }
             }
 
@@ -1138,6 +1177,12 @@ namespace Emby.Server.Implementations.Session
 
             _userDataManager.SaveUserData(user, item, data, UserDataSaveReason.PlaybackFinished, CancellationToken.None);
 
+            // A completed version marks all of its alternate versions played; positions stay per-version.
+            if (data.Played == true && item is Video playedVideo)
+            {
+                playedVideo.PropagatePlayedState(user, true);
+            }
+
             return playedToCompletion;
         }
 
diff --git a/MediaBrowser.Controller/Entities/BaseItem.cs b/MediaBrowser.Controller/Entities/BaseItem.cs
index c69e24f876..84ba560900 100644
--- a/MediaBrowser.Controller/Entities/BaseItem.cs
+++ b/MediaBrowser.Controller/Entities/BaseItem.cs
@@ -1115,17 +1115,15 @@ namespace MediaBrowser.Controller.Entities
                 }
             }
 
-            return result.OrderBy(i =>
-            {
-                if (i.VideoType == VideoType.VideoFile)
-                {
-                    return 0;
-                }
+            // The source belonging to the item being queried sorts first so it is the default the client plays.
+            var selfId = Id.ToString("N", CultureInfo.InvariantCulture);
 
-                return 1;
-            }).ThenBy(i => i.Video3DFormat.HasValue ? 1 : 0)
-            .ThenByDescending(i => i, new MediaSourceWidthComparator())
-            .ToArray();
+            return result
+                .OrderByDescending(i => string.Equals(i.Id, selfId, StringComparison.OrdinalIgnoreCase))
+                .ThenBy(i => i.VideoType == VideoType.VideoFile ? 0 : 1)
+                .ThenBy(i => i.Video3DFormat.HasValue ? 1 : 0)
+                .ThenByDescending(i => i, new MediaSourceWidthComparator())
+                .ToArray();
         }
 
         protected virtual IEnumerable<(BaseItem Item, MediaSourceType MediaSourceType)> GetAllItemsForMediaSources()
@@ -2114,12 +2112,23 @@ namespace MediaBrowser.Controller.Entities
             // I think it is okay to do this here.
             // if this is only called when a user is manually forcing something to un-played
             // then it probably is what we want to do...
+            ResetPlayedState(data);
+
+            UserDataManager.SaveUserData(user, this, data, UserDataSaveReason.TogglePlayed, CancellationToken.None);
+        }
+
+        /// <summary>
+        /// Clears the played state on the supplied user data.
+        /// </summary>
+        /// <param name="data">The user data to reset.</param>
+        protected static void ResetPlayedState(UserItemData data)
+        {
+            ArgumentNullException.ThrowIfNull(data);
+
             data.PlayCount = 0;
             data.PlaybackPositionTicks = 0;
             data.LastPlayedDate = null;
             data.Played = false;
-
-            UserDataManager.SaveUserData(user, this, data, UserDataSaveReason.TogglePlayed, CancellationToken.None);
         }
 
         /// <summary>
diff --git a/MediaBrowser.Controller/Entities/Video.cs b/MediaBrowser.Controller/Entities/Video.cs
index e7a5672ebd..168ef7d817 100644
--- a/MediaBrowser.Controller/Entities/Video.cs
+++ b/MediaBrowser.Controller/Entities/Video.cs
@@ -34,11 +34,11 @@ namespace MediaBrowser.Controller.Entities
     {
         public Video()
         {
-            AdditionalParts = Array.Empty<string>();
-            LocalAlternateVersions = Array.Empty<string>();
-            SubtitleFiles = Array.Empty<string>();
-            AudioFiles = Array.Empty<string>();
-            LinkedAlternateVersions = Array.Empty<LinkedChild>();
+            AdditionalParts = [];
+            LocalAlternateVersions = [];
+            SubtitleFiles = [];
+            AudioFiles = [];
+            LinkedAlternateVersions = [];
         }
 
         [JsonIgnore]
@@ -335,6 +335,92 @@ namespace MediaBrowser.Controller.Entities
             PresentationUniqueKey = CreatePresentationUniqueKey();
         }
 
+        /// <summary>
+        /// Marks the played status of this video and propagates it to its alternate versions.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        /// <param name="datePlayed">The date played.</param>
+        /// <param name="resetPosition">if set to <c>true</c> [reset position].</param>
+        public override void MarkPlayed(User user, DateTime? datePlayed, bool resetPosition)
+        {
+            base.MarkPlayed(user, datePlayed, resetPosition);
+            PropagatePlayedState(user, true, resetPosition);
+        }
+
+        /// <summary>
+        /// Marks this video unplayed and propagates the change to its alternate versions.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        public override void MarkUnplayed(User user)
+        {
+            base.MarkUnplayed(user);
+
+            // MarkUnplayed always clears the position on this video, so reset the versions too.
+            PropagatePlayedState(user, false, true);
+        }
+
+        /// <summary>
+        /// Propagates the played status to every alternate version of this video.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        /// <param name="played">The played status to apply to the alternate versions.</param>
+        /// <param name="resetPosition">When marking played, controls whether each version's resume point
+        /// is also reset (<c>true</c>) or left untouched (<c>false</c>). Ignored when marking unplayed,
+        /// which always fully resets every version.</param>
+        public void PropagatePlayedState(User user, bool played, bool resetPosition = true)
+        {
+            ArgumentNullException.ThrowIfNull(user);
+
+            if (!PrimaryVersionId.HasValue && LinkedAlternateVersions.Length == 0 && !HasLocalAlternateVersions)
+            {
+                return;
+            }
+
+            foreach (var (item, _) in GetAllItemsForMediaSources())
+            {
+                if (item.Id.Equals(Id) || item is not Video)
+                {
+                    continue;
+                }
+
+                if (played)
+                {
+                    var dto = new UpdateUserItemDataDto { Played = true };
+                    if (resetPosition)
+                    {
+                        dto.PlaybackPositionTicks = 0;
+                    }
+
+                    // SaveUserData only writes the fields set on the DTO, so play count and other state are preserved.
+                    UserDataManager.SaveUserData(user, item, dto, UserDataSaveReason.TogglePlayed);
+                }
+                else
+                {
+                    var data = UserDataManager.GetUserData(user, item);
+                    if (data is null)
+                    {
+                        continue;
+                    }
+
+                    ResetPlayedState(data);
+                    UserDataManager.SaveUserData(user, item, data, UserDataSaveReason.TogglePlayed, CancellationToken.None);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets the alternate version of this video that matches the supplied item id.
+        /// </summary>
+        /// <param name="itemId">The version item id (the playback media source id).</param>
+        /// <returns>The matching version, or <c>null</c> when the id is not a version of this video.</returns>
+        public Video GetAlternateVersion(Guid itemId)
+        {
+            return GetAllItemsForMediaSources()
+                .Select(i => i.Item)
+                .OfType<Video>()
+                .FirstOrDefault(i => i.Id.Equals(itemId));
+        }
+
         public override string CreatePresentationUniqueKey()
         {
             if (PrimaryVersionId.HasValue)
@@ -644,37 +730,32 @@ namespace MediaBrowser.Controller.Entities
 
         protected override IEnumerable<(BaseItem Item, MediaSourceType MediaSourceType)> GetAllItemsForMediaSources()
         {
-            var list = new List<(BaseItem, MediaSourceType)>
-            {
-                (this, MediaSourceType.Default)
-            };
-
-            list.AddRange(
-                LibraryManager.GetLinkedAlternateVersions(this)
-                    .Select(i => ((BaseItem)i, MediaSourceType.Grouping)));
-
-            if (PrimaryVersionId.HasValue)
-            {
-                if (LibraryManager.GetItemById(PrimaryVersionId.Value) is Video primary)
-                {
-                    var existingIds = list.Select(i => i.Item1.Id).ToList();
-                    list.Add((primary, MediaSourceType.Grouping));
-                    list.AddRange(LibraryManager.GetLinkedAlternateVersions(primary).Where(i => !existingIds.Contains(i.Id)).Select(i => ((BaseItem)i, MediaSourceType.Grouping)));
-                }
-            }
+            var primary = PrimaryVersionId.HasValue
+                ? LibraryManager.GetItemById(PrimaryVersionId.Value) as Video
+                : null;
+
+            // This video and its linked alternates, when this is itself an alternate, the primary and the primary's linked alternates.
+            var grouped = new[] { ((BaseItem)this, MediaSourceType.Default) }
+                .Concat(LibraryManager.GetLinkedAlternateVersions(this).Select(i => ((BaseItem)i, MediaSourceType.Grouping)))
+                .Concat(primary is null
+                    ? []
+                    : LibraryManager.GetLinkedAlternateVersions(primary).Prepend(primary).Select(i => ((BaseItem)i, MediaSourceType.Grouping)))
+                .ToList();
 
-            var localAlternates = list
-                .SelectMany(i =>
-                {
-                    return i.Item1 is Video video ? LibraryManager.GetLocalAlternateVersionIds(video) : Enumerable.Empty<Guid>();
-                })
+            // The local (file-based) alternate versions of every grouped item.
+            var localAlternates = grouped
+                .Select(i => i.Item1)
+                .OfType<Video>()
+                .SelectMany(LibraryManager.GetLocalAlternateVersionIds)
                 .Select(LibraryManager.GetItemById)
                 .Where(i => i is not null)
-                .ToList();
+                .Select(i => (i, MediaSourceType.Default));
 
-            list.AddRange(localAlternates.Select(i => (i, MediaSourceType.Default)));
-
-            return list;
+            // Deduplicate
+            return grouped
+                .Concat(localAlternates)
+                .DistinctBy(i => i.Item1.Id)
+                .ToList();
         }
     }
 }
diff --git a/MediaBrowser.Controller/Library/IUserDataManager.cs b/MediaBrowser.Controller/Library/IUserDataManager.cs
index 798812bf1f..0b4229c784 100644
--- a/MediaBrowser.Controller/Library/IUserDataManager.cs
+++ b/MediaBrowser.Controller/Library/IUserDataManager.cs
@@ -80,5 +80,13 @@ namespace MediaBrowser.Controller.Library
         /// <param name="reportedPositionTicks">New playstate.</param>
         /// <returns>True if playstate was updated.</returns>
         bool UpdatePlayState(BaseItem item, UserItemData data, long? reportedPositionTicks);
+
+        /// <summary>
+        /// Clears any stored audio and subtitle stream selections for the given user/item pair.
+        /// Used when the user has opted out of remembering selections.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        /// <param name="item">The item.</param>
+        void ResetPlaybackStreamSelections(User user, BaseItem item);
     }
 }
diff --git a/tests/Jellyfin.Controller.Tests/Entities/BaseItemTests.cs b/tests/Jellyfin.Controller.Tests/Entities/BaseItemTests.cs
index 8af176138c..2ee95f076b 100644
--- a/tests/Jellyfin.Controller.Tests/Entities/BaseItemTests.cs
+++ b/tests/Jellyfin.Controller.Tests/Entities/BaseItemTests.cs
@@ -1,6 +1,15 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Threading;
+using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.MediaSegments;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.MediaInfo;
 using Moq;
 using Xunit;
@@ -108,4 +117,199 @@ public class BaseItemTests
         Assert.Equal(expectedPrimary, video.GetMediaSourceName(video, commonPrefix));
         Assert.Equal(expectedAlt, videoAlt.GetMediaSourceName(videoAlt, commonPrefix));
     }
+
+    [Fact]
+    public void GetAlternateVersion_ReturnsMatchingLocalVersion()
+    {
+        var (primary, alt1, alt2) = SetupVersionGroup();
+
+        Assert.Same(alt1, primary.GetAlternateVersion(alt1.Id));
+        Assert.Same(alt2, primary.GetAlternateVersion(alt2.Id));
+        Assert.Same(primary, primary.GetAlternateVersion(primary.Id));
+        Assert.Null(primary.GetAlternateVersion(Guid.NewGuid()));
+    }
+
+    [Fact]
+    public void PropagatePlayedState_MarksAlternateVersions_AndResetsPositionByDefault()
+    {
+        var (primary, alt1, alt2) = SetupVersionGroup();
+
+        var saved = CaptureSaves();
+
+        var user = new User("test", "default", "default");
+        primary.PropagatePlayedState(user, true);
+
+        // Both alternate versions are marked played, the primary (self) is not, and the position is
+        // reset so a watched version does not linger in "Continue Watching".
+        Assert.Equal(2, saved.Count);
+        Assert.DoesNotContain(saved, e => e.ItemId.Equals(primary.Id));
+        Assert.Contains(saved, e => e.ItemId.Equals(alt1.Id));
+        Assert.Contains(saved, e => e.ItemId.Equals(alt2.Id));
+        Assert.All(saved, e =>
+        {
+            Assert.True(e.Dto.Played.GetValueOrDefault());
+            Assert.Equal(0, e.Dto.PlaybackPositionTicks);
+        });
+    }
+
+    [Fact]
+    public void PropagatePlayedState_WithoutReset_LeavesPositionUntouched()
+    {
+        var (primary, _, _) = SetupVersionGroup();
+
+        var saved = CaptureSaves();
+
+        primary.PropagatePlayedState(new User("test", "default", "default"), true, resetPosition: false);
+
+        Assert.Equal(2, saved.Count);
+        Assert.All(saved, e =>
+        {
+            Assert.True(e.Dto.Played.GetValueOrDefault());
+            Assert.Null(e.Dto.PlaybackPositionTicks);
+        });
+    }
+
+    [Fact]
+    public void PropagatePlayedState_Unwatched_ClearsAllWatchedStateOnVersions()
+    {
+        var (primary, alt1, alt2) = SetupVersionGroup();
+
+        // Each alternate starts out watched, with a play count, resume point and last-played date.
+        var existing = new Dictionary<Guid, UserItemData>
+        {
+            [alt1.Id] = new UserItemData { Key = "alt1", Played = true, PlayCount = 3, PlaybackPositionTicks = 1000, LastPlayedDate = new DateTime(2020, 1, 1, 0, 0, 0, DateTimeKind.Utc) },
+            [alt2.Id] = new UserItemData { Key = "alt2", Played = true, PlayCount = 1, PlaybackPositionTicks = 500, LastPlayedDate = new DateTime(2021, 2, 2, 0, 0, 0, DateTimeKind.Utc) },
+        };
+
+        var saved = new List<UserItemData>();
+        var userDataManager = new Mock<IUserDataManager>();
+        userDataManager.Setup(x => x.GetUserData(It.IsAny<User>(), It.IsAny<BaseItem>()))
+            .Returns((User _, BaseItem item) => existing.GetValueOrDefault(item.Id));
+        userDataManager
+            .Setup(x => x.SaveUserData(It.IsAny<User>(), It.IsAny<BaseItem>(), It.IsAny<UserItemData>(), It.IsAny<UserDataSaveReason>(), It.IsAny<CancellationToken>()))
+            .Callback<User, BaseItem, UserItemData, UserDataSaveReason, CancellationToken>((_, _, data, _, _) => saved.Add(data));
+        BaseItem.UserDataManager = userDataManager.Object;
+
+        primary.PropagatePlayedState(new User("test", "default", "default"), false);
+
+        // Every alternate is fully reset to an unwatched state, mirroring MarkUnplayed: the played flag,
+        // play count, resume point and last-played date are all cleared so no watched state lingers.
+        Assert.Equal(2, saved.Count);
+        Assert.All(saved, d =>
+        {
+            Assert.False(d.Played);
+            Assert.Equal(0, d.PlayCount);
+            Assert.Equal(0, d.PlaybackPositionTicks);
+            Assert.Null(d.LastPlayedDate);
+        });
+    }
+
+    private static List<(Guid ItemId, UpdateUserItemDataDto Dto)> CaptureSaves()
+    {
+        var saved = new List<(Guid ItemId, UpdateUserItemDataDto Dto)>();
+        var userDataManager = new Mock<IUserDataManager>();
+        userDataManager
+            .Setup(x => x.SaveUserData(It.IsAny<User>(), It.IsAny<BaseItem>(), It.IsAny<UpdateUserItemDataDto>(), It.IsAny<UserDataSaveReason>()))
+            .Callback<User, BaseItem, UpdateUserItemDataDto, UserDataSaveReason>((_, item, dto, _) => saved.Add((item.Id, dto)));
+        BaseItem.UserDataManager = userDataManager.Object;
+        return saved;
+    }
+
+    [Fact]
+    public void PropagatePlayedState_SingleVersion_DoesNothing()
+    {
+        var solo = new Video { Id = Guid.NewGuid(), Path = "/Movies/Solo/Solo.mkv" };
+
+        var mediaSourceManager = new Mock<IMediaSourceManager>();
+        mediaSourceManager.Setup(x => x.GetPathProtocol(It.IsAny<string>())).Returns(MediaProtocol.File);
+        var libraryManager = new Mock<ILibraryManager>();
+        libraryManager.Setup(x => x.GetLocalAlternateVersionIds(It.IsAny<Video>())).Returns(Array.Empty<Guid>());
+        libraryManager.Setup(x => x.GetLinkedAlternateVersions(It.IsAny<Video>())).Returns(Array.Empty<Video>());
+        BaseItem.MediaSourceManager = mediaSourceManager.Object;
+        BaseItem.LibraryManager = libraryManager.Object;
+
+        var userDataManager = new Mock<IUserDataManager>();
+        BaseItem.UserDataManager = userDataManager.Object;
+
+        solo.PropagatePlayedState(new User("test", "default", "default"), true);
+
+        userDataManager.Verify(
+            x => x.SaveUserData(It.IsAny<User>(), It.IsAny<BaseItem>(), It.IsAny<UpdateUserItemDataDto>(), It.IsAny<UserDataSaveReason>()),
+            Times.Never);
+    }
+
+    private static (Video Primary, Video Alt1, Video Alt2) SetupVersionGroup()
+    {
+        var primary = new Video { Id = Guid.NewGuid(), Path = "/Movies/Movie/Movie.mkv" };
+        var alt1 = new Video { Id = Guid.NewGuid(), Path = "/Movies/Movie/Movie - 1080p.mkv", PrimaryVersionId = primary.Id };
+        var alt2 = new Video { Id = Guid.NewGuid(), Path = "/Movies/Movie/Movie - 4K.mkv", PrimaryVersionId = primary.Id };
+
+        // 2160p primary, 1080p alternates: width is only the ordering tiebreaker, set so it would place
+        // the primary first — letting the tests confirm the queried version's own source still wins.
+        var widths = new Dictionary<Guid, int> { [primary.Id] = 3840, [alt1.Id] = 1920, [alt2.Id] = 1920 };
+        var mediaSourceManager = new Mock<IMediaSourceManager>();
+        mediaSourceManager.Setup(x => x.GetPathProtocol(It.IsAny<string>())).Returns(MediaProtocol.File);
+        mediaSourceManager.Setup(x => x.GetMediaStreams(It.IsAny<Guid>()))
+            .Returns((Guid id) => new List<MediaStream> { new MediaStream { Type = MediaStreamType.Video, Width = widths.GetValueOrDefault(id) } });
+        mediaSourceManager.Setup(x => x.GetMediaAttachments(It.IsAny<Guid>())).Returns(new List<MediaAttachment>());
+
+        var segmentManager = new Mock<IMediaSegmentManager>();
+        segmentManager.Setup(x => x.IsTypeSupported(It.IsAny<BaseItem>())).Returns(false);
+        BaseItem.MediaSegmentManager = segmentManager.Object;
+
+        var libraryManager = new Mock<ILibraryManager>();
+        libraryManager.Setup(x => x.GetLinkedAlternateVersions(It.IsAny<Video>())).Returns(Array.Empty<Video>());
+        libraryManager.Setup(x => x.GetLocalAlternateVersionIds(primary)).Returns(new[] { alt1.Id, alt2.Id });
+        libraryManager.Setup(x => x.GetLocalAlternateVersionIds(alt1)).Returns(Array.Empty<Guid>());
+        libraryManager.Setup(x => x.GetLocalAlternateVersionIds(alt2)).Returns(Array.Empty<Guid>());
+        libraryManager.Setup(x => x.GetItemById(alt1.Id)).Returns(alt1);
+        libraryManager.Setup(x => x.GetItemById(alt2.Id)).Returns(alt2);
+        libraryManager.Setup(x => x.GetItemById(primary.Id)).Returns(primary);
+
+        var recordingsManager = new Mock<IRecordingsManager>();
+        recordingsManager.Setup(x => x.GetActiveRecordingInfo(It.IsAny<string>())).Returns((ActiveRecordingInfo?)null);
+        Video.RecordingsManager = recordingsManager.Object;
+
+        BaseItem.MediaSourceManager = mediaSourceManager.Object;
+        BaseItem.LibraryManager = libraryManager.Object;
+
+        return (primary, alt1, alt2);
+    }
+
+    [Fact]
+    public void GetMediaSources_DefaultsToTheQueriedVersionsOwnSource()
+    {
+        var (primary, alt1, _) = SetupVersionGroup();
+
+        // Resuming the 1080p alternate must default to the 1080p source, not the higher-resolution
+        // 2160p primary that the width ordering would otherwise place first.
+        Assert.Equal(alt1.Id.ToString("N"), alt1.GetMediaSources(false)[0].Id);
+
+        // Opening the primary still defaults to the primary's own (here highest-resolution) source.
+        Assert.Equal(primary.Id.ToString("N"), primary.GetMediaSources(false)[0].Id);
+    }
+
+    [Fact]
+    public void GetAllItemsForMediaSources_FromAnyVersion_HasNoDuplicates()
+    {
+        var (primary, alt1, alt2) = SetupVersionGroup();
+
+        var method = typeof(Video).GetMethod("GetAllItemsForMediaSources", BindingFlags.Instance | BindingFlags.NonPublic);
+        Assert.NotNull(method);
+
+        // Each version must surface exactly once, regardless of which member the list is built from.
+        // Building from an alternate previously re-added that alternate as a "local alternate" of the
+        // primary, producing a duplicate entry in the version dropdown.
+        foreach (var source in new[] { primary, alt1, alt2 })
+        {
+            var items = (IEnumerable<(BaseItem Item, MediaSourceType MediaSourceType)>)method!.Invoke(source, null)!;
+            var ids = items.Select(i => i.Item.Id).ToList();
+
+            Assert.Equal(3, ids.Count);
+            Assert.Equal(ids.Count, ids.Distinct().Count());
+            Assert.Contains(primary.Id, ids);
+            Assert.Contains(alt1.Id, ids);
+            Assert.Contains(alt2.Id, ids);
+        }
+    }
 }
-- 
cgit v1.2.3


From 4725722b1ce40c4e601084a74a23368331c747de Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sun, 7 Jun 2026 22:37:34 +0200
Subject: Make ContinueWatching and NextUp version-aware

---
 Emby.Server.Implementations/TV/TVSeriesManager.cs | 96 +++++++++++++++++++++--
 1 file changed, 89 insertions(+), 7 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/TV/TVSeriesManager.cs b/Emby.Server.Implementations/TV/TVSeriesManager.cs
index 535dc01a31..9a402a5738 100644
--- a/Emby.Server.Implementations/TV/TVSeriesManager.cs
+++ b/Emby.Server.Implementations/TV/TVSeriesManager.cs
@@ -2,6 +2,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using Jellyfin.Data;
 using Jellyfin.Data.Enums;
@@ -136,11 +137,15 @@ namespace Emby.Server.Implementations.TV
 
                 if (nextEpisode is not null)
                 {
+                    // The last played date and the version that was actually played live on the version item's user data
+                    // The played state propagated to the sibling versions carries no date
+                    var (playedVersion, lastPlayedDate) = GetMostRecentlyPlayedVersion(result.LastWatched, user);
+                    nextEpisode = GetPreferredVersion(nextEpisode, result.LastWatched, playedVersion);
+
                     DateTime lastWatchedDate = DateTime.MinValue;
                     if (result.LastWatched is not null)
                     {
-                        var userData = _userDataManager.GetUserData(user, result.LastWatched);
-                        lastWatchedDate = userData?.LastPlayedDate ?? DateTime.MinValue.AddDays(1);
+                        lastWatchedDate = lastPlayedDate ?? DateTime.MinValue.AddDays(1);
                     }
 
                     nextUpList.Add((lastWatchedDate, nextEpisode));
@@ -152,11 +157,13 @@ namespace Emby.Server.Implementations.TV
 
                     if (nextPlayedEpisode is not null)
                     {
+                        var (playedVersion, lastPlayedDate) = GetMostRecentlyPlayedVersion(result.LastWatchedForRewatching, user);
+                        nextPlayedEpisode = GetPreferredVersion(nextPlayedEpisode, result.LastWatchedForRewatching, playedVersion);
+
                         DateTime rewatchLastWatchedDate = DateTime.MinValue;
                         if (result.LastWatchedForRewatching is not null)
                         {
-                            var userData = _userDataManager.GetUserData(user, result.LastWatchedForRewatching);
-                            rewatchLastWatchedDate = userData?.LastPlayedDate ?? DateTime.MinValue.AddDays(1);
+                            rewatchLastWatchedDate = lastPlayedDate ?? DateTime.MinValue.AddDays(1);
                         }
 
                         nextUpList.Add((rewatchLastWatchedDate, nextPlayedEpisode));
@@ -219,10 +226,13 @@ namespace Emby.Server.Implementations.TV
 
             if (nextEpisode is not null && !includeResumable)
             {
-                var userData = _userDataManager.GetUserData(user, nextEpisode);
-                if (userData?.PlaybackPositionTicks > 0)
+                // The resume progress may live on an alternate version
+                foreach (var version in nextEpisode.GetAllVersions())
                 {
-                    return null;
+                    if (_userDataManager.GetUserData(user, version)?.PlaybackPositionTicks > 0)
+                    {
+                        return null;
+                    }
                 }
             }
 
@@ -237,6 +247,78 @@ namespace Emby.Server.Implementations.TV
             return DetermineNextEpisode(result, user, includeSpecials, includeResumable: false, includePlayed: true);
         }
 
+        /// <summary>
+        /// Gets the version of the last watched episode that was actually played, together with its last played date.
+        /// The version that was played carries the most recent LastPlayedDate.
+        /// dates.
+        /// </summary>
+        /// <param name="lastWatched">The last watched episode (any version).</param>
+        /// <param name="user">The user.</param>
+        /// <returns>The played version and its last played date.</returns>
+        private (Video? PlayedVersion, DateTime? LastPlayedDate) GetMostRecentlyPlayedVersion(BaseItem? lastWatched, User user)
+        {
+            if (lastWatched is not Video lastWatchedVideo)
+            {
+                return (null, null);
+            }
+
+            Video? playedVersion = null;
+            DateTime? lastPlayedDate = null;
+            foreach (var version in lastWatchedVideo.GetAllVersions())
+            {
+                var data = _userDataManager.GetUserData(user, version);
+                if (data?.LastPlayedDate is { } date && (lastPlayedDate is null || date > lastPlayedDate))
+                {
+                    lastPlayedDate = date;
+                    playedVersion = version;
+                }
+            }
+
+            return (playedVersion, lastPlayedDate);
+        }
+
+        /// <summary>
+        /// When the last watched episode was played as an alternate version, prefer the next episode's version with the matching name,
+        /// so Next Up continues in the version the user has been watching instead of falling back to the primary.
+        /// </summary>
+        /// <param name="nextEpisode">The determined next episode (a primary).</param>
+        /// <param name="lastWatched">The last watched episode.</param>
+        /// <param name="playedVersion">The version of the last watched episode that was played.</param>
+        /// <returns>The matching version of the next episode, or the episode itself.</returns>
+        private Episode GetPreferredVersion(Episode nextEpisode, BaseItem? lastWatched, Video? playedVersion)
+        {
+            // No version preference, or the primary was played
+            if (lastWatched is not Video lastWatchedVideo
+                || playedVersion is null
+                || !playedVersion.PrimaryVersionId.HasValue)
+            {
+                return nextEpisode;
+            }
+
+            // Match by version name
+            var playedVersionId = playedVersion.Id.ToString("N", CultureInfo.InvariantCulture);
+            var playedVersionName = lastWatchedVideo.GetMediaSources(false)
+                .FirstOrDefault(source => string.Equals(source.Id, playedVersionId, StringComparison.OrdinalIgnoreCase))?.Name;
+
+            if (string.IsNullOrEmpty(playedVersionName))
+            {
+                return nextEpisode;
+            }
+
+            var matchingSource = nextEpisode.GetMediaSources(false)
+                .FirstOrDefault(source => string.Equals(source.Name, playedVersionName, StringComparison.OrdinalIgnoreCase));
+
+            if (matchingSource is not null
+                && Guid.TryParse(matchingSource.Id, out var matchingId)
+                && !matchingId.Equals(nextEpisode.Id)
+                && _libraryManager.GetItemById<Episode>(matchingId) is { } matchingVersion)
+            {
+                return matchingVersion;
+            }
+
+            return nextEpisode;
+        }
+
         private static string GetUniqueSeriesKey(Series series)
         {
             return series.GetPresentationUniqueKey();
-- 
cgit v1.2.3


From a53a533cc4b3e50d10369cb0007dee9b0459725a Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Sun, 7 Jun 2026 22:37:34 +0200
Subject: Respect user permissions in version count

---
 Emby.Server.Implementations/Dto/DtoService.cs | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 3cd72a8ac1..c9c31ebee4 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -369,7 +369,7 @@ namespace Emby.Server.Implementations.Dto
                 AttachStudios(dto, item);
             }
 
-            AttachBasicFields(dto, item, owner, options, artistsBatch);
+            AttachBasicFields(dto, item, owner, options, artistsBatch, user);
 
             if (options.ContainsField(ItemFields.CanDelete))
             {
@@ -943,7 +943,8 @@ namespace Emby.Server.Implementations.Dto
         /// <param name="owner">The owner.</param>
         /// <param name="options">The options.</param>
         /// <param name="artistsBatch">Optional pre-fetched artist lookup shared across a batch of items.</param>
-        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null)
+        /// <param name="user">The user, for per-user values such as the accessible media source count.</param>
+        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null, User? user = null)
         {
             if (options.ContainsField(ItemFields.DateCreated))
             {
@@ -1257,7 +1258,11 @@ namespace Emby.Server.Implementations.Dto
 
                 if (options.ContainsField(ItemFields.MediaSourceCount))
                 {
-                    var mediaSourceCount = video.MediaSourceCount;
+                    // Match the per-user filtering of the media sources: versions the user cannot
+                    // access are not selectable, so they must not count towards the badge either.
+                    var mediaSourceCount = user is null
+                        ? video.MediaSourceCount
+                        : video.GetAllVersions().Count(v => v.Id.Equals(video.Id) || v.IsVisibleStandalone(user));
                     if (mediaSourceCount != 1)
                     {
                         dto.MediaSourceCount = mediaSourceCount;
-- 
cgit v1.2.3


From 1bfbad24200e89273464d6aabcbb1d36ac1813df Mon Sep 17 00:00:00 2001
From: Elio Kuster <eliokuster.essay132@passmail.com>
Date: Fri, 13 Mar 2026 11:22:56 +0100
Subject: Fix missing collection folder posters after initial scans.

Fixes #1200
---
 CONTRIBUTORS.md                                    |  1 +
 .../CollectionPosterVerifyPostScanTask.cs          | 64 ++++++++++++++++++++++
 2 files changed, 65 insertions(+)
 create mode 100644 Emby.Server.Implementations/Library/Validators/CollectionPosterVerifyPostScanTask.cs

(limited to 'Emby.Server.Implementations')

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index d70ffddfd7..a4a9793ccc 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -232,6 +232,7 @@
  - [MSalman5230](https://github.com/MSalman5230)
  - [dwandw](https://github.com/dwandw)
  - [Lampan-git](https://github.com/Lampan-git)
+ - [elio42](https://github.com/elio42)
 
 # Emby Contributors
 
diff --git a/Emby.Server.Implementations/Library/Validators/CollectionPosterVerifyPostScanTask.cs b/Emby.Server.Implementations/Library/Validators/CollectionPosterVerifyPostScanTask.cs
new file mode 100644
index 0000000000..2cfa446862
--- /dev/null
+++ b/Emby.Server.Implementations/Library/Validators/CollectionPosterVerifyPostScanTask.cs
@@ -0,0 +1,64 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Ensures top-level library folders have a primary poster after scans.
+/// Poster extraction is attempted before library scanning. When a library is
+/// empty at that point, no poster can be extracted. This post-scan task reruns
+/// metadata extraction for top-level folders that are still missing images.
+/// </summary>
+public class CollectionPosterVerifyPostScanTask : ILibraryPostScanTask
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly ILogger<CollectionPosterVerifyPostScanTask> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CollectionPosterVerifyPostScanTask" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    public CollectionPosterVerifyPostScanTask(
+        ILibraryManager libraryManager,
+        ILogger<CollectionPosterVerifyPostScanTask> logger)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var libraries = _libraryManager.GetUserRootFolder().Children.OfType<CollectionFolder>().ToList();
+        var totalLibraries = libraries.Count;
+        var processedLibraries = 0;
+
+        foreach (var library in libraries)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (!library.HasImage(ImageType.Primary))
+            {
+                _logger.LogDebug("Library {LibraryName} is missing a primary image. Refreshing metadata.", library.Name);
+                await library.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+            }
+
+            processedLibraries++;
+            progress.Report((double)processedLibraries / totalLibraries * 100);
+        }
+
+        progress.Report(100);
+    }
+}
-- 
cgit v1.2.3


From 0874a26131a5a1e9d62fb7231acbaf9eb921b5c8 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Tue, 9 Jun 2026 23:23:03 +0200
Subject: Coalesce alternate-version progress onto primary in resume filter

---
 Emby.Server.Implementations/Dto/DtoService.cs      |  19 ++-
 .../Library/MediaSourceManager.cs                  |  72 +++++++++-
 .../Library/UserDataManager.cs                     |  70 ++++++++++
 .../Item/BaseItemRepository.TranslateQuery.cs      |  18 ++-
 .../Library/IUserDataManager.cs                    |  18 +++
 .../Library/VersionResumeData.cs                   |  30 +++++
 MediaBrowser.Model/Dto/MediaSourceInfo.cs          |   5 +
 .../Library/VersionResumeDataTests.cs              |  44 ++++++
 .../Item/AlternateVersionQueryTranslationTests.cs  | 147 +++++++++++++++++++++
 .../Library/MediaSourceManagerTests.cs             | 110 +++++++++++++++
 10 files changed, 525 insertions(+), 8 deletions(-)
 create mode 100644 MediaBrowser.Controller/Library/VersionResumeData.cs
 create mode 100644 tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
 create mode 100644 tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index c9c31ebee4..2bf478953e 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -167,9 +167,13 @@ namespace Emby.Server.Implementations.Dto
 
             // Batch-fetch user data for all items
             Dictionary<Guid, UserItemData>? userDataBatch = null;
+            IReadOnlyDictionary<Guid, VersionResumeData>? resumeDataBatch = null;
             if (user is not null && options.EnableUserData)
             {
                 userDataBatch = _userDataRepository.GetUserDataBatch(accessibleItems, user);
+
+                // For items with alternate versions, the most recently played version drives resume.
+                resumeDataBatch = _userDataRepository.GetResumeUserDataBatch(accessibleItems, user);
             }
 
             // Pre-compute collection folders once to avoid N+1 queries in CanDelete
@@ -248,7 +252,8 @@ namespace Emby.Server.Implementations.Dto
                     allCollectionFolders,
                     childCountBatch,
                     playedCountBatch,
-                    artistsBatch);
+                    artistsBatch,
+                    resumeDataBatch?.GetValueOrDefault(item.Id));
 
                 if (item is LiveTvChannel tvChannel)
                 {
@@ -309,7 +314,8 @@ namespace Emby.Server.Implementations.Dto
             List<Folder>? allCollectionFolders = null,
             Dictionary<Guid, int>? childCountBatch = null,
             Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null,
-            IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null)
+            IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null,
+            VersionResumeData? resumeData = null)
         {
             var dto = new BaseItemDto
             {
@@ -353,7 +359,8 @@ namespace Emby.Server.Implementations.Dto
                     options,
                     userData,
                     childCountBatch,
-                    playedCountBatch);
+                    playedCountBatch,
+                    resumeData);
             }
 
             if (item is IHasMediaSources
@@ -538,7 +545,8 @@ namespace Emby.Server.Implementations.Dto
             DtoOptions options,
             UserItemData? userData = null,
             Dictionary<Guid, int>? childCountBatch = null,
-            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null)
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null,
+            VersionResumeData? resumeData = null)
         {
             if (item.IsFolder)
             {
@@ -600,6 +608,9 @@ namespace Emby.Server.Implementations.Dto
                         // Use pre-fetched user data
                         dto.UserData = GetUserItemDataDto(userData, item.Id);
                         item.FillUserDataDtoValues(dto.UserData, userData, dto, user, options);
+
+                        // For items with alternate versions, the most recently played version drives resume.
+                        resumeData?.ApplyTo(dto.UserData);
                     }
                     else
                     {
diff --git a/Emby.Server.Implementations/Library/MediaSourceManager.cs b/Emby.Server.Implementations/Library/MediaSourceManager.cs
index 9ccfefa86e..4a520cad0d 100644
--- a/Emby.Server.Implementations/Library/MediaSourceManager.cs
+++ b/Emby.Server.Implementations/Library/MediaSourceManager.cs
@@ -229,7 +229,11 @@ namespace Emby.Server.Implementations.Library
                 list.Add(source);
             }
 
-            return SortMediaSources(list).ToArray();
+            var preferredId = mediaSources.Count > 0 && Guid.TryParse(mediaSources[0].Id, out var topSourceId)
+                ? topSourceId
+                : item.Id;
+
+            return SortMediaSources(list, preferredId).ToArray();
         }
 
         /// <inheritdoc />>
@@ -400,6 +404,72 @@ namespace Emby.Server.Implementations.Library
                         source.SupportsDirectStream = user.HasPermission(PermissionKind.EnablePlaybackRemuxing);
                     }
                 }
+
+                sources = SetAlternateVersionResumeStates(item, sources, user);
+            }
+
+            return sources;
+        }
+
+        /// <summary>
+        /// Populates each source's own playback position for the user and, when the queried item is a
+        /// primary, moves the most recently played version to the front so that resuming without an
+        /// explicit source selection plays the version that was last watched. A directly queried
+        /// alternate version keeps its own source first.
+        /// </summary>
+        /// <param name="item">The queried item.</param>
+        /// <param name="sources">The item's media sources.</param>
+        /// <param name="user">The user.</param>
+        /// <returns>The media sources, reordered when a version drives resume.</returns>
+        private IReadOnlyList<MediaSourceInfo> SetAlternateVersionResumeStates(BaseItem item, IReadOnlyList<MediaSourceInfo> sources, User user)
+        {
+            // For a video, multiple sources means alternate versions.
+            if (item is not Video video || sources.Count < 2)
+            {
+                return sources;
+            }
+
+            var versions = video.GetAllVersions();
+            if (versions.Count < 2)
+            {
+                return sources;
+            }
+
+            var userDataByVersion = _userDataManager.GetUserDataBatch(versions, user);
+            var dataBySourceId = new Dictionary<string, UserItemData>(versions.Count, StringComparer.OrdinalIgnoreCase);
+            foreach (var version in versions)
+            {
+                if (userDataByVersion.TryGetValue(version.Id, out var data))
+                {
+                    dataBySourceId[version.Id.ToString("N", CultureInfo.InvariantCulture)] = data;
+                }
+            }
+
+            MediaSourceInfo resumeSource = null;
+            UserItemData resumeData = null;
+            foreach (var source in sources)
+            {
+                if (source.Id is null
+                    || !dataBySourceId.TryGetValue(source.Id, out var data)
+                    || data.PlaybackPositionTicks <= 0)
+                {
+                    continue;
+                }
+
+                source.PlaybackPositionTicks = data.PlaybackPositionTicks;
+
+                if (resumeData is null || (data.LastPlayedDate ?? DateTime.MinValue) > (resumeData.LastPlayedDate ?? DateTime.MinValue))
+                {
+                    resumeSource = source;
+                    resumeData = data;
+                }
+            }
+
+            if (resumeSource is not null && !video.PrimaryVersionId.HasValue && !ReferenceEquals(sources[0], resumeSource))
+            {
+                var reordered = new List<MediaSourceInfo>(sources.Count) { resumeSource };
+                reordered.AddRange(sources.Where(s => !ReferenceEquals(s, resumeSource)));
+                return reordered;
             }
 
             return sources;
diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index 962dd6fda8..4fda853bb1 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -247,6 +247,72 @@ namespace Emby.Server.Implementations.Library
             return result;
         }
 
+        /// <inheritdoc />
+        public VersionResumeData? GetResumeUserData(User user, BaseItem item)
+        {
+            return GetResumeUserDataBatch([item], user).GetValueOrDefault(item.Id);
+        }
+
+        /// <inheritdoc />
+        public IReadOnlyDictionary<Guid, VersionResumeData> GetResumeUserDataBatch(IReadOnlyList<BaseItem> items, User user)
+        {
+            ArgumentNullException.ThrowIfNull(user);
+
+            var result = new Dictionary<Guid, VersionResumeData>();
+            List<(Guid PrimaryId, IReadOnlyList<Video> Versions)>? versionGroups = null;
+            List<BaseItem>? allVersions = null;
+
+            foreach (var item in items)
+            {
+                // Only primary items aggregate over their versions; a directly queried version keeps its own data.
+                if (item is not Video video
+                    || video.PrimaryVersionId.HasValue
+                    || (video.LinkedAlternateVersions.Length == 0 && !video.HasLocalAlternateVersions))
+                {
+                    continue;
+                }
+
+                var versions = video.GetAllVersions();
+                if (versions.Count < 2)
+                {
+                    continue;
+                }
+
+                (versionGroups ??= []).Add((item.Id, versions));
+                (allVersions ??= []).AddRange(versions);
+            }
+
+            if (versionGroups is null)
+            {
+                return result;
+            }
+
+            var userDataByVersion = GetUserDataBatch(allVersions!.DistinctBy(i => i.Id).ToList(), user);
+
+            foreach (var (primaryId, versions) in versionGroups)
+            {
+                Video? resumeVersion = null;
+                UserItemData? resumeData = null;
+                foreach (var version in versions)
+                {
+                    if (userDataByVersion.TryGetValue(version.Id, out var data)
+                        && data.PlaybackPositionTicks > 0
+                        && (resumeData is null || (data.LastPlayedDate ?? DateTime.MinValue) > (resumeData.LastPlayedDate ?? DateTime.MinValue)))
+                    {
+                        resumeVersion = version;
+                        resumeData = data;
+                    }
+                }
+
+                if (resumeData is not null)
+                {
+                    result[primaryId] = new VersionResumeData(resumeData, resumeVersion!.RunTimeTicks);
+                }
+            }
+
+            return result;
+        }
+
         /// <summary>
         /// Gets the internal key.
         /// </summary>
@@ -281,6 +347,10 @@ namespace Emby.Server.Implementations.Library
             var dto = GetUserItemDataDto(userData, item.Id);
 
             item.FillUserDataDtoValues(dto, userData, itemDto, user, options);
+
+            // For an item with alternate versions, surface the most recently played version's resume point.
+            GetResumeUserData(user, item)?.ApplyTo(dto);
+
             return dto;
         }
 
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
index 22f7cc3550..a9856f2e76 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
@@ -519,7 +519,6 @@ public sealed partial class BaseItemRepository
             // In-progress user data rows; alternate versions track their own progress.
             var inProgress = context.UserData
                 .Where(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0);
-            var resumableItemIds = inProgress.Select(ud => ud.ItemId);
 
             if (hasSeries)
             {
@@ -544,13 +543,26 @@ public sealed partial class BaseItemRepository
                     .Where(s => s.HasInProgress || (s.HasPlayed && s.HasUnplayed))
                     .Select(s => s.SeriesId);
 
+                // Non-series items: resumable if the item or any of its alternate versions has
+                // PlaybackPositionTicks > 0. Alternate versions (PrimaryVersionId set) are excluded
+                // from the base query, so coalesce their progress onto the primary's id.
+                var resumableMovieIds = context.BaseItems
+                    .Where(bi => bi.UserData!.Any(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0))
+                    .Select(bi => bi.PrimaryVersionId ?? bi.Id);
+
                 baseQuery = baseQuery.Where(e =>
                     (e.Type == seriesTypeName && resumableSeriesIds.Contains(e.Id) == isResumable)
-                    || (e.Type != seriesTypeName && resumableItemIds.Contains(e.Id) == isResumable));
+                    || (e.Type != seriesTypeName && resumableMovieIds.Contains(e.Id) == isResumable));
             }
             else
             {
-                baseQuery = baseQuery.Where(e => resumableItemIds.Contains(e.Id) == isResumable);
+                // Resumable if the item or any of its alternate versions has PlaybackPositionTicks > 0.
+                // Alternate versions (PrimaryVersionId set) are excluded from the base query, so
+                // coalesce their progress onto the primary's id.
+                var resumableMovieIds = context.BaseItems
+                    .Where(bi => bi.UserData!.Any(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0))
+                    .Select(bi => bi.PrimaryVersionId ?? bi.Id);
+                baseQuery = baseQuery.Where(e => resumableMovieIds.Contains(e.Id) == isResumable);
             }
 
             if (isResumable)
diff --git a/MediaBrowser.Controller/Library/IUserDataManager.cs b/MediaBrowser.Controller/Library/IUserDataManager.cs
index 0b4229c784..2ee8845346 100644
--- a/MediaBrowser.Controller/Library/IUserDataManager.cs
+++ b/MediaBrowser.Controller/Library/IUserDataManager.cs
@@ -62,6 +62,24 @@ namespace MediaBrowser.Controller.Library
         /// <returns>A dictionary mapping item IDs to their user data.</returns>
         Dictionary<Guid, UserItemData> GetUserDataBatch(IReadOnlyList<BaseItem> items, User user);
 
+        /// <summary>
+        /// Gets the user data that should drive resume for a multi-version item: the data of the most
+        /// recently played alternate version (including the item itself) that has a resume point.
+        /// </summary>
+        /// <param name="user">The user.</param>
+        /// <param name="item">The item.</param>
+        /// <returns>The resume version's data, or <c>null</c> when the item has no versions or none has a resume point.</returns>
+        VersionResumeData? GetResumeUserData(User user, BaseItem item);
+
+        /// <summary>
+        /// Gets the resume-driving user data for multiple items in a single batch operation.
+        /// See <see cref="GetResumeUserData(User, BaseItem)"/>.
+        /// </summary>
+        /// <param name="items">The items to get resume data for.</param>
+        /// <param name="user">The user.</param>
+        /// <returns>A dictionary mapping item ids to their resume version's data; items without one are omitted.</returns>
+        IReadOnlyDictionary<Guid, VersionResumeData> GetResumeUserDataBatch(IReadOnlyList<BaseItem> items, User user);
+
         /// <summary>
         /// Gets the user data dto.
         /// </summary>
diff --git a/MediaBrowser.Controller/Library/VersionResumeData.cs b/MediaBrowser.Controller/Library/VersionResumeData.cs
new file mode 100644
index 0000000000..ca8a499d97
--- /dev/null
+++ b/MediaBrowser.Controller/Library/VersionResumeData.cs
@@ -0,0 +1,30 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Dto;
+
+namespace MediaBrowser.Controller.Library
+{
+    /// <summary>
+    /// The user data of the alternate version that should drive resume for a multi-version item.
+    /// </summary>
+    /// <param name="UserData">The resume version's user data.</param>
+    /// <param name="RunTimeTicks">The resume version's runtime, used for the progress percentage.</param>
+    public record VersionResumeData(UserItemData UserData, long? RunTimeTicks)
+    {
+        /// <summary>
+        /// Applies the resume version's playback state to the supplied user data dto, so that an item
+        /// whose most recent progress lives on an alternate version still reports that progress.
+        /// </summary>
+        /// <param name="dto">The user data dto to update.</param>
+        public void ApplyTo(UserItemDataDto dto)
+        {
+            dto.PlaybackPositionTicks = UserData.PlaybackPositionTicks;
+            dto.Played = UserData.Played;
+            dto.LastPlayedDate = UserData.LastPlayedDate;
+
+            if (RunTimeTicks > 0 && UserData.PlaybackPositionTicks > 0)
+            {
+                dto.PlayedPercentage = 100.0 * UserData.PlaybackPositionTicks / RunTimeTicks.Value;
+            }
+        }
+    }
+}
diff --git a/MediaBrowser.Model/Dto/MediaSourceInfo.cs b/MediaBrowser.Model/Dto/MediaSourceInfo.cs
index 75ccdcf276..017e26ef59 100644
--- a/MediaBrowser.Model/Dto/MediaSourceInfo.cs
+++ b/MediaBrowser.Model/Dto/MediaSourceInfo.cs
@@ -55,6 +55,11 @@ namespace MediaBrowser.Model.Dto
 
         public long? RunTimeTicks { get; set; }
 
+        /// <summary>
+        /// Gets or sets the playback position for this specific source.
+        /// </summary>
+        public long? PlaybackPositionTicks { get; set; }
+
         public bool ReadAtNativeFramerate { get; set; }
 
         public bool IgnoreDts { get; set; }
diff --git a/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs b/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
new file mode 100644
index 0000000000..5b0f003019
--- /dev/null
+++ b/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
@@ -0,0 +1,44 @@
+using System;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Dto;
+using Xunit;
+
+namespace Jellyfin.Controller.Tests.Library;
+
+public class VersionResumeDataTests
+{
+    [Fact]
+    public void ApplyTo_OverridesResumeFieldsAndPercentage()
+    {
+        var lastPlayed = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc);
+        var resume = new VersionResumeData(
+            new UserItemData { Key = "version", PlaybackPositionTicks = 25, Played = true, LastPlayedDate = lastPlayed },
+            RunTimeTicks: 100);
+
+        var dto = new UserItemDataDto { Key = "primary", PlaybackPositionTicks = 1, Played = false, PlayedPercentage = 1 };
+
+        resume.ApplyTo(dto);
+
+        Assert.Equal(25, dto.PlaybackPositionTicks);
+        Assert.True(dto.Played);
+        Assert.Equal(lastPlayed, dto.LastPlayedDate);
+
+        // The percentage is based on the resume version's own runtime, not the primary's.
+        Assert.NotNull(dto.PlayedPercentage);
+        Assert.Equal(25.0, dto.PlayedPercentage.Value, 5);
+    }
+
+    [Fact]
+    public void ApplyTo_WithoutRuntime_LeavesPercentageUntouched()
+    {
+        var resume = new VersionResumeData(new UserItemData { Key = "version", PlaybackPositionTicks = 25 }, null);
+        var dto = new UserItemDataDto { Key = "primary", PlayedPercentage = 42 };
+
+        resume.ApplyTo(dto);
+
+        Assert.Equal(25, dto.PlaybackPositionTicks);
+        Assert.NotNull(dto.PlayedPercentage);
+        Assert.Equal(42.0, dto.PlayedPercentage.Value, 5);
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
new file mode 100644
index 0000000000..e6e591a20e
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
@@ -0,0 +1,147 @@
+#pragma warning disable RS0030 // Do not use banned APIs: Guid == is required inside EF expression trees to mirror the production query shapes.
+
+using System;
+using System.Linq;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Locking;
+using Jellyfin.Database.Providers.Sqlite;
+using Microsoft.Data.Sqlite;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Item;
+
+/// <summary>
+/// Verifies that the alternate-version-aware query shapes used by the resume filter
+/// (BaseItemRepository.TranslateQuery) and the DatePlayed ordering (OrderMapper) translate
+/// and evaluate correctly on the SQLite provider.
+/// </summary>
+public sealed class AlternateVersionQueryTranslationTests : IDisposable
+{
+    private readonly SqliteConnection _connection;
+    private readonly DbContextOptions<JellyfinDbContext> _dbOptions;
+
+    public AlternateVersionQueryTranslationTests()
+    {
+        _connection = new SqliteConnection("Data Source=:memory:");
+        _connection.Open();
+
+        _dbOptions = new DbContextOptionsBuilder<JellyfinDbContext>()
+            .UseSqlite(_connection)
+            .Options;
+
+        using var ctx = CreateDbContext();
+        ctx.Database.EnsureCreated();
+    }
+
+    [Fact]
+    public void ResumeFilter_VersionProgress_SurfacesPrimary()
+    {
+        Guid userId, primaryId, otherId;
+
+        using (var ctx = CreateDbContext())
+        {
+            (userId, primaryId, otherId) = Seed(ctx);
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            // Mirrors the resumable filter in BaseItemRepository.TranslateQuery: progress on any
+            // version coalesces onto the primary's id.
+            var resumableMovieIds = ctx.BaseItems
+                .Where(bi => bi.UserData!.Any(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0))
+                .Select(bi => bi.PrimaryVersionId ?? bi.Id);
+
+            // Scope to the seeded items; EnsureCreated also seeds a placeholder row.
+            var seededIds = new[] { primaryId, otherId };
+
+            var resumable = ctx.BaseItems
+                .Where(e => seededIds.Contains(e.Id) && e.PrimaryVersionId == null)
+                .Where(e => resumableMovieIds.Contains(e.Id))
+                .Select(e => e.Id)
+                .ToList();
+
+            Assert.Equal([primaryId], resumable);
+
+            // The inverse (not-resumable) direction must exclude the primary as well.
+            var notResumable = ctx.BaseItems
+                .Where(e => seededIds.Contains(e.Id) && e.PrimaryVersionId == null)
+                .Where(e => resumableMovieIds.Contains(e.Id) == false)
+                .Select(e => e.Id)
+                .ToList();
+
+            Assert.Equal([otherId], notResumable);
+        }
+    }
+
+    [Fact]
+    public void DatePlayedOrdering_VersionProgress_SortsPrimaryByVersionDate()
+    {
+        Guid userId, primaryId, otherId;
+
+        using (var ctx = CreateDbContext())
+        {
+            (userId, primaryId, otherId) = Seed(ctx);
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            // Scope to the seeded items; EnsureCreated also seeds a placeholder row.
+            var seededIds = new[] { primaryId, otherId };
+
+            // Mirrors the DatePlayed mapping in OrderMapper.
+            var ordered = ctx.BaseItems
+                .Where(e => seededIds.Contains(e.Id) && e.PrimaryVersionId == null)
+                .OrderByDescending(e => ctx.UserData
+                    .Where(w => w.UserId == userId && (w.ItemId == e.Id || w.Item!.PrimaryVersionId == e.Id))
+                    .Max(f => f.LastPlayedDate))
+                .Select(e => e.Id)
+                .ToList();
+
+            // The movie whose only progress is on its alternate version sorts before the unplayed one.
+            Assert.Equal([primaryId, otherId], ordered);
+        }
+    }
+
+    private static (Guid UserId, Guid PrimaryId, Guid OtherId) Seed(JellyfinDbContext ctx)
+    {
+        var user = new User("test", "auth-provider", "reset-provider");
+        ctx.Users.Add(user);
+
+        var primary = new BaseItemEntity { Id = Guid.NewGuid(), Type = "MediaBrowser.Controller.Entities.Movies.Movie" };
+        var version = new BaseItemEntity { Id = Guid.NewGuid(), Type = "MediaBrowser.Controller.Entities.Movies.Movie", PrimaryVersionId = primary.Id };
+        var other = new BaseItemEntity { Id = Guid.NewGuid(), Type = "MediaBrowser.Controller.Entities.Movies.Movie" };
+        ctx.BaseItems.AddRange(primary, version, other);
+
+        // Progress only on the alternate version.
+        ctx.UserData.Add(new UserData
+        {
+            ItemId = version.Id,
+            Item = version,
+            UserId = user.Id,
+            User = user,
+            CustomDataKey = version.Id.ToString("N"),
+            PlaybackPositionTicks = 1000,
+            LastPlayedDate = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc)
+        });
+
+        ctx.SaveChanges();
+        return (user.Id, primary.Id, other.Id);
+    }
+
+    private JellyfinDbContext CreateDbContext()
+    {
+        return new JellyfinDbContext(
+            _dbOptions,
+            NullLogger<JellyfinDbContext>.Instance,
+            new SqliteDatabaseProvider(null!, NullLogger<SqliteDatabaseProvider>.Instance),
+            new NoLockBehavior(NullLogger<NoLockBehavior>.Instance));
+    }
+
+    public void Dispose()
+    {
+        _connection.Dispose();
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
index facdb2bc2e..b788fb304e 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using AutoFixture;
 using AutoFixture.AutoMoq;
 using Castle.Components.DictionaryAdapter;
@@ -7,6 +9,8 @@ using Emby.Server.Implementations.Library;
 using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.MediaSegments;
 using MediaBrowser.Model.Dto;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Globalization;
@@ -144,5 +148,111 @@ namespace Jellyfin.Server.Implementations.Tests.Library
             _mediaSourceManager.SetDefaultAudioAndSubtitleStreamIndices(_item, mediaInfo, _user);
             Assert.Equal(expectedIndex, mediaInfo.DefaultAudioStreamIndex);
         }
+
+        [Fact]
+        public void GetStaticMediaSources_PrimaryQueried_PopulatesPerVersionPositionsAndDefaultsToMostRecent()
+        {
+            var (primary, alt1, alt2) = SetupVersionGroup();
+            SetupUserDataBatch(new Dictionary<Guid, UserItemData>
+            {
+                [alt1.Id] = new UserItemData { Key = "alt1", PlaybackPositionTicks = 10, LastPlayedDate = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc) },
+                [alt2.Id] = new UserItemData { Key = "alt2", PlaybackPositionTicks = 20, LastPlayedDate = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc) }
+            });
+
+            var sources = _mediaSourceManager.GetStaticMediaSources(primary, false, _user);
+
+            // Each version carries its own resume point; the primary has none.
+            Assert.Equal((long?)10, sources.First(s => s.Id == alt1.Id.ToString("N")).PlaybackPositionTicks);
+            Assert.Equal((long?)20, sources.First(s => s.Id == alt2.Id.ToString("N")).PlaybackPositionTicks);
+            Assert.Null(sources.First(s => s.Id == primary.Id.ToString("N")).PlaybackPositionTicks);
+
+            // The most recently played version is the default source, so resuming plays the right file.
+            Assert.Equal(alt2.Id.ToString("N"), sources[0].Id);
+        }
+
+        [Fact]
+        public void GetStaticMediaSources_AlternateQueried_KeepsOwnSourceFirst()
+        {
+            var (primary, alt1, alt2) = SetupVersionGroup();
+            SetupUserDataBatch(new Dictionary<Guid, UserItemData>
+            {
+                [alt2.Id] = new UserItemData { Key = "alt2", PlaybackPositionTicks = 20, LastPlayedDate = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc) }
+            });
+
+            var sources = _mediaSourceManager.GetStaticMediaSources(alt1, false, _user);
+
+            // An explicitly opened version keeps its own source first, even when a sibling was
+            // played more recently, but the sibling's resume point is still populated.
+            Assert.Equal(alt1.Id.ToString("N"), sources[0].Id);
+            Assert.Equal((long?)20, sources.First(s => s.Id == alt2.Id.ToString("N")).PlaybackPositionTicks);
+            Assert.Equal(3, sources.Count);
+        }
+
+        [Fact]
+        public void GetStaticMediaSources_NoProgress_KeepsQueriedItemFirst()
+        {
+            var (primary, _, _) = SetupVersionGroup();
+            SetupUserDataBatch([]);
+
+            var sources = _mediaSourceManager.GetStaticMediaSources(primary, false, _user);
+
+            Assert.Equal(primary.Id.ToString("N"), sources[0].Id);
+            Assert.All(sources, s => Assert.Null(s.PlaybackPositionTicks));
+        }
+
+        [Fact]
+        public void GetStaticMediaSources_NoUser_DoesNotTouchUserData()
+        {
+            var (primary, _, _) = SetupVersionGroup();
+
+            var sources = _mediaSourceManager.GetStaticMediaSources(primary, false);
+
+            Assert.Equal(primary.Id.ToString("N"), sources[0].Id);
+            _mockUserDataManager.Verify(x => x.GetUserDataBatch(It.IsAny<IReadOnlyList<BaseItem>>(), It.IsAny<User>()), Times.Never);
+        }
+
+        private void SetupUserDataBatch(Dictionary<Guid, UserItemData> userData)
+        {
+            _mockUserDataManager
+                .Setup(x => x.GetUserDataBatch(It.IsAny<IReadOnlyList<BaseItem>>(), It.IsAny<User>()))
+                .Returns((IReadOnlyList<BaseItem> items, User _) => items
+                    .Where(i => userData.ContainsKey(i.Id))
+                    .ToDictionary(i => i.Id, i => userData[i.Id]));
+        }
+
+        private static (Video Primary, Video Alt1, Video Alt2) SetupVersionGroup()
+        {
+            var primary = new Video { Id = Guid.NewGuid(), Path = "/Movies/Movie/Movie.mkv" };
+            var alt1 = new Video { Id = Guid.NewGuid(), Path = "/Movies/Movie/Movie - 1080p.mkv", PrimaryVersionId = primary.Id };
+            var alt2 = new Video { Id = Guid.NewGuid(), Path = "/Movies/Movie/Movie - 4K.mkv", PrimaryVersionId = primary.Id };
+
+            // BaseItem.GetMediaSources runs against the static service locators.
+            var mediaSourceManager = new Mock<IMediaSourceManager>();
+            mediaSourceManager.Setup(x => x.GetPathProtocol(It.IsAny<string>())).Returns(MediaProtocol.File);
+            mediaSourceManager.Setup(x => x.GetMediaStreams(It.IsAny<Guid>())).Returns(new List<MediaStream>());
+            mediaSourceManager.Setup(x => x.GetMediaAttachments(It.IsAny<Guid>())).Returns(new List<MediaAttachment>());
+
+            var segmentManager = new Mock<IMediaSegmentManager>();
+            segmentManager.Setup(x => x.IsTypeSupported(It.IsAny<BaseItem>())).Returns(false);
+
+            var libraryManager = new Mock<ILibraryManager>();
+            libraryManager.Setup(x => x.GetLinkedAlternateVersions(It.IsAny<Video>())).Returns(Array.Empty<Video>());
+            libraryManager.Setup(x => x.GetLocalAlternateVersionIds(primary)).Returns(new[] { alt1.Id, alt2.Id });
+            libraryManager.Setup(x => x.GetLocalAlternateVersionIds(alt1)).Returns(Array.Empty<Guid>());
+            libraryManager.Setup(x => x.GetLocalAlternateVersionIds(alt2)).Returns(Array.Empty<Guid>());
+            libraryManager.Setup(x => x.GetItemById(primary.Id)).Returns(primary);
+            libraryManager.Setup(x => x.GetItemById(alt1.Id)).Returns(alt1);
+            libraryManager.Setup(x => x.GetItemById(alt2.Id)).Returns(alt2);
+
+            var recordingsManager = new Mock<IRecordingsManager>();
+            recordingsManager.Setup(x => x.GetActiveRecordingInfo(It.IsAny<string>())).Returns((ActiveRecordingInfo?)null);
+
+            BaseItem.MediaSegmentManager = segmentManager.Object;
+            BaseItem.MediaSourceManager = mediaSourceManager.Object;
+            BaseItem.LibraryManager = libraryManager.Object;
+            Video.RecordingsManager = recordingsManager.Object;
+
+            return (primary, alt1, alt2);
+        }
     }
 }
-- 
cgit v1.2.3


From 0aeee8233bd0e602bd4523125d2c44b847d3fc7a Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 12 Jun 2026 08:09:10 +0200
Subject: Fix performance

---
 .../Library/UserDataManager.cs                     | 50 +++++++++++++++++++---
 .../Item/BaseItemRepository.TranslateQuery.cs      | 10 ++---
 .../Item/AlternateVersionQueryTranslationTests.cs  |  7 +--
 3 files changed, 52 insertions(+), 15 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index 4fda853bb1..bedaacee33 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -259,15 +259,53 @@ namespace Emby.Server.Implementations.Library
             ArgumentNullException.ThrowIfNull(user);
 
             var result = new Dictionary<Guid, VersionResumeData>();
+
+            // Candidate primaries: a directly queried version (PrimaryVersionId set) keeps its own data.
+            // Linked alternates are already known in memory; only the local-alternate existence check
+            // would otherwise hit the database (one query per item via Video.HasLocalAlternateVersions),
+            // so collect those ids and resolve them all in a single query below.
+            List<Video>? candidates = null;
+            List<Guid>? localProbeIds = null;
+            foreach (var item in items)
+            {
+                if (item is not Video video || video.PrimaryVersionId.HasValue)
+                {
+                    continue;
+                }
+
+                (candidates ??= []).Add(video);
+
+                if (video.LinkedAlternateVersions.Length == 0)
+                {
+                    (localProbeIds ??= []).Add(video.Id);
+                }
+            }
+
+            if (candidates is null)
+            {
+                return result;
+            }
+
+            HashSet<Guid>? withLocalAlternates = null;
+            if (localProbeIds is not null)
+            {
+                using var dbContext = _repository.CreateDbContext();
+                withLocalAlternates = dbContext.LinkedChildren
+                    .Where(lc => lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.LocalAlternateVersion
+                        && localProbeIds.Contains(lc.ParentId))
+                    .Select(lc => lc.ParentId)
+                    .Distinct()
+                    .ToHashSet();
+            }
+
             List<(Guid PrimaryId, IReadOnlyList<Video> Versions)>? versionGroups = null;
             List<BaseItem>? allVersions = null;
 
-            foreach (var item in items)
+            foreach (var video in candidates)
             {
-                // Only primary items aggregate over their versions; a directly queried version keeps its own data.
-                if (item is not Video video
-                    || video.PrimaryVersionId.HasValue
-                    || (video.LinkedAlternateVersions.Length == 0 && !video.HasLocalAlternateVersions))
+                // Only items that actually have alternate versions aggregate over them.
+                if (video.LinkedAlternateVersions.Length == 0
+                    && (withLocalAlternates is null || !withLocalAlternates.Contains(video.Id)))
                 {
                     continue;
                 }
@@ -278,7 +316,7 @@ namespace Emby.Server.Implementations.Library
                     continue;
                 }
 
-                (versionGroups ??= []).Add((item.Id, versions));
+                (versionGroups ??= []).Add((video.Id, versions));
                 (allVersions ??= []).AddRange(versions);
             }
 
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
index a9856f2e76..96d6d2eaff 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
@@ -546,9 +546,8 @@ public sealed partial class BaseItemRepository
                 // Non-series items: resumable if the item or any of its alternate versions has
                 // PlaybackPositionTicks > 0. Alternate versions (PrimaryVersionId set) are excluded
                 // from the base query, so coalesce their progress onto the primary's id.
-                var resumableMovieIds = context.BaseItems
-                    .Where(bi => bi.UserData!.Any(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0))
-                    .Select(bi => bi.PrimaryVersionId ?? bi.Id);
+                var resumableMovieIds = inProgress
+                    .Join(context.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);
 
                 baseQuery = baseQuery.Where(e =>
                     (e.Type == seriesTypeName && resumableSeriesIds.Contains(e.Id) == isResumable)
@@ -559,9 +558,8 @@ public sealed partial class BaseItemRepository
                 // Resumable if the item or any of its alternate versions has PlaybackPositionTicks > 0.
                 // Alternate versions (PrimaryVersionId set) are excluded from the base query, so
                 // coalesce their progress onto the primary's id.
-                var resumableMovieIds = context.BaseItems
-                    .Where(bi => bi.UserData!.Any(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0))
-                    .Select(bi => bi.PrimaryVersionId ?? bi.Id);
+                var resumableMovieIds = inProgress
+                    .Join(context.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);
                 baseQuery = baseQuery.Where(e => resumableMovieIds.Contains(e.Id) == isResumable);
             }
 
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
index e6e591a20e..823ff566a7 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
@@ -50,9 +50,10 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
         {
             // Mirrors the resumable filter in BaseItemRepository.TranslateQuery: progress on any
             // version coalesces onto the primary's id.
-            var resumableMovieIds = ctx.BaseItems
-                .Where(bi => bi.UserData!.Any(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0))
-                .Select(bi => bi.PrimaryVersionId ?? bi.Id);
+            var inProgress = ctx.UserData
+                .Where(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0);
+            var resumableMovieIds = inProgress
+                .Join(ctx.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);
 
             // Scope to the seeded items; EnsureCreated also seeds a placeholder row.
             var seededIds = new[] { primaryId, otherId };
-- 
cgit v1.2.3


From 24886d48494ab579c860654a908dbbe7fa5b8525 Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Fri, 19 Jun 2026 11:24:27 -0400
Subject: Remove orphaned people

---
 .../ScheduledTasks/Tasks/PeopleValidationTask.cs        | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
index 6e4e5c7808..abe75c8d67 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
@@ -9,6 +9,7 @@ using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Globalization;
 using MediaBrowser.Model.Tasks;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace Emby.Server.Implementations.ScheduledTasks.Tasks;
 
@@ -20,6 +21,7 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     private readonly ILibraryManager _libraryManager;
     private readonly ILocalizationManager _localization;
     private readonly IDbContextFactory<JellyfinDbContext> _dbContextFactory;
+    private readonly ILogger<PeopleValidationTask> _logger;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PeopleValidationTask" /> class.
@@ -27,11 +29,13 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
     /// <param name="localization">Instance of the <see cref="ILocalizationManager"/> interface.</param>
     /// <param name="dbContextFactory">Instance of the <see cref="IDbContextFactory{TContext}"/> interface.</param>
-    public PeopleValidationTask(ILibraryManager libraryManager, ILocalizationManager localization, IDbContextFactory<JellyfinDbContext> dbContextFactory)
+    /// <param name="logger">Instance of the <see cref="ILogger{PeopleValidationTask}"/> interface.</param>
+    public PeopleValidationTask(ILibraryManager libraryManager, ILocalizationManager localization, IDbContextFactory<JellyfinDbContext> dbContextFactory, ILogger<PeopleValidationTask> logger)
     {
         _libraryManager = libraryManager;
         _localization = localization;
         _dbContextFactory = dbContextFactory;
+        _logger = logger;
     }
 
     /// <inheritdoc />
@@ -71,13 +75,13 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     /// <inheritdoc />
     public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
     {
-        IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 2));
+        IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 3));
         await _libraryManager.ValidatePeopleAsync(subProgress, cancellationToken).ConfigureAwait(false);
 
-        subProgress = new Progress<double>((val) => progress.Report((val / 2) + 50));
         var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
         await using (context.ConfigureAwait(false))
         {
+            subProgress = new Progress<double>((val) => progress.Report((val / 3) + 33));
             var dupQuery = context.Peoples
                     .GroupBy(e => new { e.Name, e.PersonType })
                     .Where(e => e.Count() > 1)
@@ -124,6 +128,13 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
             }
 
             subProgress.Report(100);
+            var peopleToDelete = await context.Peoples
+                .Where(p => !context.PeopleBaseItemMap.Any(m => m.PeopleId.Equals(p.Id)))
+                .ExecuteDeleteAsync(cancellationToken)
+                .ConfigureAwait(false);
+            _logger.LogInformation("Removed {Count} orphaned people.", peopleToDelete);
+
+            progress.Report(100);
         }
     }
 }
-- 
cgit v1.2.3


From 0fb042b7403ebd7578b696aba35ba0c582ccf6ba Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 19 Jun 2026 21:51:57 +0200
Subject: Surface the played version for resume

---
 .../Library/UserDataManager.cs                     |  7 ++-
 .../Item/BaseItemRepository.TranslateQuery.cs      | 59 ++++++++++++----------
 .../Item/BaseItemRepository.cs                     |  8 +++
 .../Library/VersionResumeData.cs                   | 20 ++++----
 .../Library/VersionResumeDataTests.cs              | 30 ++++++-----
 .../Item/AlternateVersionQueryTranslationTests.cs  | 36 +++++++------
 6 files changed, 90 insertions(+), 70 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index bedaacee33..61372f8b56 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -329,22 +329,21 @@ namespace Emby.Server.Implementations.Library
 
             foreach (var (primaryId, versions) in versionGroups)
             {
-                Video? resumeVersion = null;
                 UserItemData? resumeData = null;
                 foreach (var version in versions)
                 {
+                    // Consider both in-progress and completed versions so a finished alternate still marks the primary as played.
                     if (userDataByVersion.TryGetValue(version.Id, out var data)
-                        && data.PlaybackPositionTicks > 0
+                        && (data.PlaybackPositionTicks > 0 || data.Played)
                         && (resumeData is null || (data.LastPlayedDate ?? DateTime.MinValue) > (resumeData.LastPlayedDate ?? DateTime.MinValue)))
                     {
-                        resumeVersion = version;
                         resumeData = data;
                     }
                 }
 
                 if (resumeData is not null)
                 {
-                    result[primaryId] = new VersionResumeData(resumeData, resumeVersion!.RunTimeTicks);
+                    result[primaryId] = new VersionResumeData(resumeData);
                 }
             }
 
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
index 96d6d2eaff..c234f333af 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
@@ -515,15 +515,15 @@ public sealed partial class BaseItemRepository
             var hasSeries = filter.IncludeItemTypes.Contains(BaseItemKind.Series);
             var userId = filter.User!.Id;
             var isResumable = filter.IsResumable.Value;
+            var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];
 
             // In-progress user data rows; alternate versions track their own progress.
             var inProgress = context.UserData
                 .Where(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0);
 
+            IQueryable<Guid>? resumableSeriesIds = null;
             if (hasSeries)
             {
-                var seriesTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Series];
-
                 // Aggregate per series in a single GROUP BY pass, instead of three full scans.
                 var seriesEpisodeStats = context.BaseItems
                     .AsNoTracking()
@@ -539,39 +539,41 @@ public sealed partial class BaseItemRepository
 
                 // A series is resumable if it has an in-progress episode,
                 // or if it has both played and unplayed episodes (partially watched).
-                var resumableSeriesIds = seriesEpisodeStats
+                resumableSeriesIds = seriesEpisodeStats
                     .Where(s => s.HasInProgress || (s.HasPlayed && s.HasUnplayed))
                     .Select(s => s.SeriesId);
-
-                // Non-series items: resumable if the item or any of its alternate versions has
-                // PlaybackPositionTicks > 0. Alternate versions (PrimaryVersionId set) are excluded
-                // from the base query, so coalesce their progress onto the primary's id.
-                var resumableMovieIds = inProgress
-                    .Join(context.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);
-
-                baseQuery = baseQuery.Where(e =>
-                    (e.Type == seriesTypeName && resumableSeriesIds.Contains(e.Id) == isResumable)
-                    || (e.Type != seriesTypeName && resumableMovieIds.Contains(e.Id) == isResumable));
-            }
-            else
-            {
-                // Resumable if the item or any of its alternate versions has PlaybackPositionTicks > 0.
-                // Alternate versions (PrimaryVersionId set) are excluded from the base query, so
-                // coalesce their progress onto the primary's id.
-                var resumableMovieIds = inProgress
-                    .Join(context.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);
-                baseQuery = baseQuery.Where(e => resumableMovieIds.Contains(e.Id) == isResumable);
             }
 
             if (isResumable)
             {
-                // Multi-version items surface as the version that was actually played.
+                // Resume queries surface the version that was actually played, which may be an alternate.
+                // Match each version on its own progress rather than coalescing onto the primary.
+                var inProgressIds = inProgress.Select(ud => ud.ItemId);
+
+                baseQuery = hasSeries
+                    ? baseQuery.Where(e =>
+                        (e.Type == seriesTypeName && resumableSeriesIds!.Contains(e.Id))
+                        || (e.Type != seriesTypeName && inProgressIds.Contains(e.Id)))
+                    : baseQuery.Where(e => inProgressIds.Contains(e.Id));
+
                 // When several versions of the same item are in progress, keep only the most recently played one.
-                baseQuery = baseQuery.Where(e => !context.BaseItems
+                baseQuery = baseQuery.Where(e => e.Type == seriesTypeName || !context.BaseItems
                     .Where(s => s.Id != e.Id && (s.PrimaryVersionId ?? s.Id) == (e.PrimaryVersionId ?? e.Id))
                     .Any(s => inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
                         > inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)));
             }
+            else
+            {
+                // Not-resumable queries operate on primaries only.
+                var resumableMovieIds = inProgress
+                    .Join(context.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);
+
+                baseQuery = hasSeries
+                    ? baseQuery.Where(e =>
+                        (e.Type == seriesTypeName && !resumableSeriesIds!.Contains(e.Id))
+                        || (e.Type != seriesTypeName && !resumableMovieIds.Contains(e.Id)))
+                    : baseQuery.Where(e => !resumableMovieIds.Contains(e.Id));
+            }
         }
 
         if (filter.ArtistIds.Length > 0)
@@ -758,10 +760,13 @@ public sealed partial class BaseItemRepository
         }
         else if (filter.OwnerIds.Length == 0 && filter.ExtraTypes.Length == 0 && !filter.IncludeOwnedItems)
         {
-            // Exclude alternate versions and owned non-extra items from general queries.
-            // Alternate versions have PrimaryVersionId set (pointing to their primary).
+            // Exclude owned non-extra items from general queries.
             // Extras (trailers, etc.) have OwnerId set but also have ExtraType set - keep those.
-            baseQuery = baseQuery.Where(e => e.PrimaryVersionId == null && (e.OwnerId == null || e.ExtraType != null));
+            // Alternate versions (PrimaryVersionId set) are normally excluded too, but resume queries
+            // keep them so the actually-played version can surface instead of collapsing onto the primary.
+            baseQuery = filter.IsResumable == true
+                ? baseQuery.Where(e => e.OwnerId == null || e.ExtraType != null)
+                : baseQuery.Where(e => e.PrimaryVersionId == null && (e.OwnerId == null || e.ExtraType != null));
         }
 
         if (filter.OwnerIds.Length > 0)
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 94dedaeba8..57041276b7 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -167,6 +167,14 @@ public sealed partial class BaseItemRepository
             return false;
         }
 
+        // Resume queries surface the actually-played version (which may be an alternate sharing the
+        // primary's presentation key). The resumable filter already keeps one version per group, so
+        // presentation-key grouping must not collapse the surfaced version back onto the primary.
+        if (query.IsResumable == true)
+        {
+            return false;
+        }
+
         if (query.GroupBySeriesPresentationUniqueKey)
         {
             return false;
diff --git a/MediaBrowser.Controller/Library/VersionResumeData.cs b/MediaBrowser.Controller/Library/VersionResumeData.cs
index ca8a499d97..455fe739ce 100644
--- a/MediaBrowser.Controller/Library/VersionResumeData.cs
+++ b/MediaBrowser.Controller/Library/VersionResumeData.cs
@@ -1,29 +1,29 @@
+using System;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Model.Dto;
 
 namespace MediaBrowser.Controller.Library
 {
     /// <summary>
-    /// The user data of the alternate version that should drive resume for a multi-version item.
+    /// The user data of the most recently played alternate version that should drive the completion state of a multi-version item.
     /// </summary>
     /// <param name="UserData">The resume version's user data.</param>
-    /// <param name="RunTimeTicks">The resume version's runtime, used for the progress percentage.</param>
-    public record VersionResumeData(UserItemData UserData, long? RunTimeTicks)
+    public record VersionResumeData(UserItemData UserData)
     {
         /// <summary>
-        /// Applies the resume version's playback state to the supplied user data dto, so that an item
-        /// whose most recent progress lives on an alternate version still reports that progress.
+        /// Merges the most recently played version's completion state into the supplied user data dto.
+        /// Only completion (played) propagates to the primary; the in-progress resume position stays on
+        /// the version that owns it, which is surfaced directly (e.g. in resume queries) so that playback
+        /// always targets the correct version rather than resuming the primary at another version's offset.
         /// </summary>
         /// <param name="dto">The user data dto to update.</param>
         public void ApplyTo(UserItemDataDto dto)
         {
-            dto.PlaybackPositionTicks = UserData.PlaybackPositionTicks;
-            dto.Played = UserData.Played;
-            dto.LastPlayedDate = UserData.LastPlayedDate;
+            dto.Played = dto.Played || UserData.Played;
 
-            if (RunTimeTicks > 0 && UserData.PlaybackPositionTicks > 0)
+            if ((UserData.LastPlayedDate ?? DateTime.MinValue) > (dto.LastPlayedDate ?? DateTime.MinValue))
             {
-                dto.PlayedPercentage = 100.0 * UserData.PlaybackPositionTicks / RunTimeTicks.Value;
+                dto.LastPlayedDate = UserData.LastPlayedDate;
             }
         }
     }
diff --git a/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs b/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
index 5b0f003019..8642ab07f8 100644
--- a/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
+++ b/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
@@ -9,36 +9,40 @@ namespace Jellyfin.Controller.Tests.Library;
 public class VersionResumeDataTests
 {
     [Fact]
-    public void ApplyTo_OverridesResumeFieldsAndPercentage()
+    public void ApplyTo_PropagatesCompletionButNotPosition()
     {
         var lastPlayed = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc);
         var resume = new VersionResumeData(
-            new UserItemData { Key = "version", PlaybackPositionTicks = 25, Played = true, LastPlayedDate = lastPlayed },
-            RunTimeTicks: 100);
+            new UserItemData { Key = "version", PlaybackPositionTicks = 25, Played = true, LastPlayedDate = lastPlayed });
 
         var dto = new UserItemDataDto { Key = "primary", PlaybackPositionTicks = 1, Played = false, PlayedPercentage = 1 };
 
         resume.ApplyTo(dto);
 
-        Assert.Equal(25, dto.PlaybackPositionTicks);
+        // Completion state propagates to the primary...
         Assert.True(dto.Played);
         Assert.Equal(lastPlayed, dto.LastPlayedDate);
 
-        // The percentage is based on the resume version's own runtime, not the primary's.
-        Assert.NotNull(dto.PlayedPercentage);
-        Assert.Equal(25.0, dto.PlayedPercentage.Value, 5);
+        // ...but the in-progress resume position stays on the version that owns it.
+        Assert.Equal(1, dto.PlaybackPositionTicks);
+        Assert.Equal(1.0, dto.PlayedPercentage);
     }
 
     [Fact]
-    public void ApplyTo_WithoutRuntime_LeavesPercentageUntouched()
+    public void ApplyTo_DoesNotUnsetExistingPlayedOrRegressLastPlayed()
     {
-        var resume = new VersionResumeData(new UserItemData { Key = "version", PlaybackPositionTicks = 25 }, null);
-        var dto = new UserItemDataDto { Key = "primary", PlayedPercentage = 42 };
+        var primaryLastPlayed = new DateTime(2026, 1, 5, 0, 0, 0, DateTimeKind.Utc);
+        var versionLastPlayed = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc);
+        var resume = new VersionResumeData(
+            new UserItemData { Key = "version", Played = false, LastPlayedDate = versionLastPlayed });
+
+        var dto = new UserItemDataDto { Key = "primary", Played = true, LastPlayedDate = primaryLastPlayed };
 
         resume.ApplyTo(dto);
 
-        Assert.Equal(25, dto.PlaybackPositionTicks);
-        Assert.NotNull(dto.PlayedPercentage);
-        Assert.Equal(42.0, dto.PlayedPercentage.Value, 5);
+        // A not-yet-completed version must not clear the primary's own completion, and the more recent
+        // LastPlayedDate is kept.
+        Assert.True(dto.Played);
+        Assert.Equal(primaryLastPlayed, dto.LastPlayedDate);
     }
 }
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
index 823ff566a7..1f0de153a0 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
@@ -37,39 +37,43 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
     }
 
     [Fact]
-    public void ResumeFilter_VersionProgress_SurfacesPrimary()
+    public void ResumeFilter_VersionProgress_SurfacesPlayedVersion()
     {
-        Guid userId, primaryId, otherId;
+        Guid userId, primaryId, versionId, otherId;
 
         using (var ctx = CreateDbContext())
         {
-            (userId, primaryId, otherId) = Seed(ctx);
+            (userId, primaryId, versionId, otherId) = Seed(ctx);
         }
 
         using (var ctx = CreateDbContext())
         {
-            // Mirrors the resumable filter in BaseItemRepository.TranslateQuery: progress on any
-            // version coalesces onto the primary's id.
             var inProgress = ctx.UserData
                 .Where(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0);
-            var resumableMovieIds = inProgress
-                .Join(ctx.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);
 
             // Scope to the seeded items; EnsureCreated also seeds a placeholder row.
-            var seededIds = new[] { primaryId, otherId };
+            var seededIds = new[] { primaryId, versionId, otherId };
 
+            // Mirrors the resumable=true filter in BaseItemRepository.TranslateQuery.
+            var inProgressIds = inProgress.Select(ud => ud.ItemId);
             var resumable = ctx.BaseItems
-                .Where(e => seededIds.Contains(e.Id) && e.PrimaryVersionId == null)
-                .Where(e => resumableMovieIds.Contains(e.Id))
+                .Where(e => seededIds.Contains(e.Id))
+                .Where(e => inProgressIds.Contains(e.Id))
+                .Where(e => !ctx.BaseItems
+                    .Where(s => s.Id != e.Id && (s.PrimaryVersionId ?? s.Id) == (e.PrimaryVersionId ?? e.Id))
+                    .Any(s => inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
+                        > inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)))
                 .Select(e => e.Id)
                 .ToList();
 
-            Assert.Equal([primaryId], resumable);
+            Assert.Equal([versionId], resumable);
 
-            // The inverse (not-resumable) direction must exclude the primary as well.
+            // The not-resumable direction keeps primaries only.
+            var resumableMovieIds = inProgress
+                .Join(ctx.BaseItems, ud => ud.ItemId, bi => bi.Id, (ud, bi) => bi.PrimaryVersionId ?? bi.Id);
             var notResumable = ctx.BaseItems
                 .Where(e => seededIds.Contains(e.Id) && e.PrimaryVersionId == null)
-                .Where(e => resumableMovieIds.Contains(e.Id) == false)
+                .Where(e => !resumableMovieIds.Contains(e.Id))
                 .Select(e => e.Id)
                 .ToList();
 
@@ -84,7 +88,7 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
 
         using (var ctx = CreateDbContext())
         {
-            (userId, primaryId, otherId) = Seed(ctx);
+            (userId, primaryId, _, otherId) = Seed(ctx);
         }
 
         using (var ctx = CreateDbContext())
@@ -106,7 +110,7 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
         }
     }
 
-    private static (Guid UserId, Guid PrimaryId, Guid OtherId) Seed(JellyfinDbContext ctx)
+    private static (Guid UserId, Guid PrimaryId, Guid VersionId, Guid OtherId) Seed(JellyfinDbContext ctx)
     {
         var user = new User("test", "auth-provider", "reset-provider");
         ctx.Users.Add(user);
@@ -129,7 +133,7 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
         });
 
         ctx.SaveChanges();
-        return (user.Id, primary.Id, other.Id);
+        return (user.Id, primary.Id, version.Id, other.Id);
     }
 
     private JellyfinDbContext CreateDbContext()
-- 
cgit v1.2.3


From 310a47c1d4f241346cc4cda4e025758bf1e6247c Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Fri, 19 Jun 2026 23:10:32 -0400
Subject: Reorder ValidatePeople

---
 .../ScheduledTasks/Tasks/PeopleValidationTask.cs            | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
index abe75c8d67..96483ced99 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
@@ -75,13 +75,10 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     /// <inheritdoc />
     public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
     {
-        IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 3));
-        await _libraryManager.ValidatePeopleAsync(subProgress, cancellationToken).ConfigureAwait(false);
-
         var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
         await using (context.ConfigureAwait(false))
         {
-            subProgress = new Progress<double>((val) => progress.Report((val / 3) + 33));
+            IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 2));
             var dupQuery = context.Peoples
                     .GroupBy(e => new { e.Name, e.PersonType })
                     .Where(e => e.Count() > 1)
@@ -127,14 +124,18 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
                 ArrayPool<Guid[]>.Shared.Return(buffer);
             }
 
-            subProgress.Report(100);
             var peopleToDelete = await context.Peoples
                 .Where(p => !context.PeopleBaseItemMap.Any(m => m.PeopleId.Equals(p.Id)))
                 .ExecuteDeleteAsync(cancellationToken)
                 .ConfigureAwait(false);
             _logger.LogInformation("Removed {Count} orphaned people.", peopleToDelete);
 
-            progress.Report(100);
+            subProgress.Report(100);
         }
+
+        IProgress<double> validateProgress = new Progress<double>((val) => progress.Report((val / 2) + 50));
+        await _libraryManager.ValidatePeopleAsync(validateProgress, cancellationToken).ConfigureAwait(false);
+
+        progress.Report(100);
     }
 }
-- 
cgit v1.2.3


From e26f4a10059feba50017a9b5dd1851a658e46298 Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Wed, 24 Jun 2026 22:30:12 -0400
Subject: Fix Live TV tuner not releasing

---
 Emby.Server.Implementations/Session/SessionManager.cs | 4 ++++
 1 file changed, 4 insertions(+)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Session/SessionManager.cs b/Emby.Server.Implementations/Session/SessionManager.cs
index 18811ef3a9..19823dff37 100644
--- a/Emby.Server.Implementations/Session/SessionManager.cs
+++ b/Emby.Server.Implementations/Session/SessionManager.cs
@@ -343,6 +343,10 @@ namespace Emby.Server.Implementations.Session
                     _activeLiveStreamSessions.TryRemove(liveStreamId, out _);
                 }
             }
+            else
+            {
+                liveStreamNeedsToBeClosed = true;
+            }
 
             if (liveStreamNeedsToBeClosed)
             {
-- 
cgit v1.2.3


From 1947296edd449e9a7244d18716fcb8ff0e9f0dc8 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 25 Jun 2026 19:32:36 +0200
Subject: Don't run heavy DB tasks while scan is running

---
 .../ScheduledTasks/Tasks/OptimizeDatabaseTask.cs         | 16 +++++++++++++++-
 .../ScheduledTasks/Tasks/PeopleValidationTask.cs         |  7 +++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/OptimizeDatabaseTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/OptimizeDatabaseTask.cs
index 92d7a3907a..8d133dc074 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/OptimizeDatabaseTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/OptimizeDatabaseTask.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Database.Implementations;
+using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Globalization;
 using MediaBrowser.Model.Tasks;
 using Microsoft.Extensions.Logging;
@@ -17,6 +18,7 @@ public class OptimizeDatabaseTask : IScheduledTask, IConfigurableScheduledTask
     private readonly ILogger<OptimizeDatabaseTask> _logger;
     private readonly ILocalizationManager _localization;
     private readonly IJellyfinDatabaseProvider _jellyfinDatabaseProvider;
+    private readonly ILibraryManager _libraryManager;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="OptimizeDatabaseTask" /> class.
@@ -24,14 +26,17 @@ public class OptimizeDatabaseTask : IScheduledTask, IConfigurableScheduledTask
     /// <param name="logger">Instance of the <see cref="ILogger"/> interface.</param>
     /// <param name="localization">Instance of the <see cref="ILocalizationManager"/> interface.</param>
     /// <param name="jellyfinDatabaseProvider">Instance of the JellyfinDatabaseProvider that can be used for provider specific operations.</param>
+    /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
     public OptimizeDatabaseTask(
         ILogger<OptimizeDatabaseTask> logger,
         ILocalizationManager localization,
-        IJellyfinDatabaseProvider jellyfinDatabaseProvider)
+        IJellyfinDatabaseProvider jellyfinDatabaseProvider,
+        ILibraryManager libraryManager)
     {
         _logger = logger;
         _localization = localization;
         _jellyfinDatabaseProvider = jellyfinDatabaseProvider;
+        _libraryManager = libraryManager;
     }
 
     /// <inheritdoc />
@@ -68,6 +73,15 @@ public class OptimizeDatabaseTask : IScheduledTask, IConfigurableScheduledTask
     /// <inheritdoc />
     public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
     {
+        // Vacuuming/checkpointing requires an exclusive lock on the database. Running it while a library scan is in
+        // progress causes both operations to contend for the database and can stall the scan, so defer optimization
+        // until no scan is running. The task will run again on its next trigger.
+        if (_libraryManager.IsScanRunning)
+        {
+            _logger.LogInformation("Skipping database optimization because a library scan is currently running.");
+            return;
+        }
+
         _logger.LogInformation("Optimizing and vacuuming jellyfin.db...");
 
         try
diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
index 6e4e5c7808..2a38b8c446 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
@@ -71,6 +71,13 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     /// <inheritdoc />
     public async Task ExecuteAsync(IProgress<double> progress, CancellationToken cancellationToken)
     {
+        // People validation performs heavy database writes that contend with an active library scan.
+        // Defer it until the scan has finished; the task will run again on its next trigger.
+        if (_libraryManager.IsScanRunning)
+        {
+            return;
+        }
+
         IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 2));
         await _libraryManager.ValidatePeopleAsync(subProgress, cancellationToken).ConfigureAwait(false);
 
-- 
cgit v1.2.3


From b9db4566a74ec94bcd24e7333b9d0cc6156e2e25 Mon Sep 17 00:00:00 2001
From: cloudharps <cloudharps@gmail.com>
Date: Thu, 25 Jun 2026 02:57:41 -0400
Subject: Translated using Weblate (Korean) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/ko/

---
 Emby.Server.Implementations/Localization/Core/ko.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/ko.json b/Emby.Server.Implementations/Localization/Core/ko.json
index 5d64405d19..a210125d34 100644
--- a/Emby.Server.Implementations/Localization/Core/ko.json
+++ b/Emby.Server.Implementations/Localization/Core/ko.json
@@ -106,5 +106,7 @@
     "TaskDownloadMissingLyrics": "누락된 가사 다운로드",
     "TaskDownloadMissingLyricsDescription": "가사 다운로드",
     "CleanupUserDataTask": "사용자 데이터 정리 작업",
-    "CleanupUserDataTaskDescription": "최소 90일 이상 존재하지 않는 미디어에 대한 사용자 데이터(시청 상태, 즐겨찾기 등)를 정리합니다."
+    "CleanupUserDataTaskDescription": "최소 90일 이상 존재하지 않는 미디어에 대한 사용자 데이터(시청 상태, 즐겨찾기 등)를 정리합니다.",
+    "LyricDownloadFailureFromForItem": "{1}에 대한 가사를 {0}에서 다운로드하지 못했습니다",
+    "Original": "원본"
 }
-- 
cgit v1.2.3


From fa07a3abe89b6e0eb96a9f8d8a3eb57dea20ca2a Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 26 Jun 2026 07:34:19 +0200
Subject: Skip backups whens can is running

---
 .../ScheduledTasks/Tasks/PeopleValidationTask.cs          |  7 ++++++-
 .../FullSystemBackup/BackupService.cs                     | 15 ++++++++++++++-
 2 files changed, 20 insertions(+), 2 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
index 2a38b8c446..305f98790d 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
@@ -9,6 +9,7 @@ using MediaBrowser.Controller.Library;
 using MediaBrowser.Model.Globalization;
 using MediaBrowser.Model.Tasks;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 
 namespace Emby.Server.Implementations.ScheduledTasks.Tasks;
 
@@ -20,6 +21,7 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     private readonly ILibraryManager _libraryManager;
     private readonly ILocalizationManager _localization;
     private readonly IDbContextFactory<JellyfinDbContext> _dbContextFactory;
+    private readonly ILogger<PeopleValidationTask> _logger;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PeopleValidationTask" /> class.
@@ -27,11 +29,13 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
     /// <param name="localization">Instance of the <see cref="ILocalizationManager"/> interface.</param>
     /// <param name="dbContextFactory">Instance of the <see cref="IDbContextFactory{TContext}"/> interface.</param>
-    public PeopleValidationTask(ILibraryManager libraryManager, ILocalizationManager localization, IDbContextFactory<JellyfinDbContext> dbContextFactory)
+    /// <param name="logger">Instance of the <see cref="ILogger{TCategoryName}"/> interface.</param>
+    public PeopleValidationTask(ILibraryManager libraryManager, ILocalizationManager localization, IDbContextFactory<JellyfinDbContext> dbContextFactory, ILogger<PeopleValidationTask> logger)
     {
         _libraryManager = libraryManager;
         _localization = localization;
         _dbContextFactory = dbContextFactory;
+        _logger = logger;
     }
 
     /// <inheritdoc />
@@ -75,6 +79,7 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
         // Defer it until the scan has finished; the task will run again on its next trigger.
         if (_libraryManager.IsScanRunning)
         {
+            _logger.LogInformation("Skipping people validation because a library scan is currently running.");
             return;
         }
 
diff --git a/Jellyfin.Server.Implementations/FullSystemBackup/BackupService.cs b/Jellyfin.Server.Implementations/FullSystemBackup/BackupService.cs
index a6dc5458ee..a534fa5fa0 100644
--- a/Jellyfin.Server.Implementations/FullSystemBackup/BackupService.cs
+++ b/Jellyfin.Server.Implementations/FullSystemBackup/BackupService.cs
@@ -12,6 +12,7 @@ using Jellyfin.Database.Implementations;
 using Jellyfin.Server.Implementations.StorageHelpers;
 using Jellyfin.Server.Implementations.SystemBackupService;
 using MediaBrowser.Controller;
+using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.SystemBackupService;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
@@ -33,6 +34,7 @@ public class BackupService : IBackupService
     private readonly IServerApplicationPaths _applicationPaths;
     private readonly IJellyfinDatabaseProvider _jellyfinDatabaseProvider;
     private readonly IHostApplicationLifetime _hostApplicationLifetime;
+    private readonly ILibraryManager _libraryManager;
     private static readonly JsonSerializerOptions _serializerSettings = new JsonSerializerOptions(JsonSerializerDefaults.General)
     {
         AllowTrailingCommas = true,
@@ -50,13 +52,15 @@ public class BackupService : IBackupService
     /// <param name="applicationPaths">The application paths.</param>
     /// <param name="jellyfinDatabaseProvider">The Jellyfin database Provider in use.</param>
     /// <param name="applicationLifetime">The SystemManager.</param>
+    /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
     public BackupService(
         ILogger<BackupService> logger,
         IDbContextFactory<JellyfinDbContext> dbProvider,
         IServerApplicationHost applicationHost,
         IServerApplicationPaths applicationPaths,
         IJellyfinDatabaseProvider jellyfinDatabaseProvider,
-        IHostApplicationLifetime applicationLifetime)
+        IHostApplicationLifetime applicationLifetime,
+        ILibraryManager libraryManager)
     {
         _logger = logger;
         _dbProvider = dbProvider;
@@ -64,6 +68,7 @@ public class BackupService : IBackupService
         _applicationPaths = applicationPaths;
         _jellyfinDatabaseProvider = jellyfinDatabaseProvider;
         _hostApplicationLifetime = applicationLifetime;
+        _libraryManager = libraryManager;
     }
 
     /// <inheritdoc/>
@@ -263,6 +268,14 @@ public class BackupService : IBackupService
     /// <inheritdoc/>
     public async Task<BackupManifestDto> CreateBackupAsync(BackupOptionsDto backupOptions)
     {
+        // Creating a backup runs a database optimization and reads the entire database under a transaction, both of
+        // which heavily contend with an active library scan and could capture an inconsistent database state.
+        if (_libraryManager.IsScanRunning)
+        {
+            _logger.LogWarning("Cannot create a backup while a library scan is running.");
+            throw new InvalidOperationException("Cannot create a backup while a library scan is running. Please try again once the scan has finished.");
+        }
+
         var manifest = new BackupManifest()
         {
             DateCreated = DateTime.UtcNow,
-- 
cgit v1.2.3


From f398b6d08b46544f61523c6871624201a2b54dfc Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 26 Jun 2026 08:20:55 +0200
Subject: Fix localization lookup

---
 .../Localization/Core/en_US.json                   | 64 ----------------------
 .../Localization/LocalizationManager.cs            | 10 +++-
 .../Localization/LocalizationManagerTests.cs       | 14 +++++
 3 files changed, 21 insertions(+), 67 deletions(-)
 delete mode 100644 Emby.Server.Implementations/Localization/Core/en_US.json

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/en_US.json b/Emby.Server.Implementations/Localization/Core/en_US.json
deleted file mode 100644
index b093f73099..0000000000
--- a/Emby.Server.Implementations/Localization/Core/en_US.json
+++ /dev/null
@@ -1,64 +0,0 @@
-{
-    "AppDeviceValues": "App: {0}, Device: {1}",
-    "Artists": "Artists",
-    "AuthenticationSucceededWithUserName": "{0} successfully authenticated",
-    "Books": "Books",
-    "ChapterNameValue": "Chapter {0}",
-    "Collections": "Collections",
-    "Default": "Default",
-    "External": "External",
-    "FailedLoginAttemptWithUserName": "Failed login attempt from {0}",
-    "Favorites": "Favorites",
-    "Folders": "Folders",
-    "Forced": "Forced",
-    "Genres": "Genres",
-    "HeaderContinueWatching": "Continue Watching",
-    "HeaderFavoriteEpisodes": "Favorite Episodes",
-    "HeaderFavoriteShows": "Favorite Shows",
-    "HeaderLiveTV": "Live TV",
-    "HeaderNextUp": "Next Up",
-    "HearingImpaired": "Hearing Impaired",
-    "HomeVideos": "Home Videos",
-    "Inherit": "Inherit",
-    "LabelIpAddressValue": "IP address: {0}",
-    "LabelRunningTimeValue": "Running time: {0}",
-    "Latest": "Latest",
-    "LyricDownloadFailureFromForItem": "Lyrics failed to download from {0} for {1}",
-    "MixedContent": "Mixed content",
-    "Movies": "Movies",
-    "Music": "Music",
-    "MusicVideos": "Music Videos",
-    "NameInstallFailed": "{0} installation failed",
-    "NameSeasonNumber": "Season {0}",
-    "NameSeasonUnknown": "Season Unknown",
-    "NewVersionIsAvailable": "A new version of Jellyfin Server is available for download.",
-    "NotificationOptionApplicationUpdateAvailable": "Application update available",
-    "NotificationOptionApplicationUpdateInstalled": "Application update installed",
-    "NotificationOptionAudioPlayback": "Audio playback started",
-    "NotificationOptionAudioPlaybackStopped": "Audio playback stopped",
-    "NotificationOptionCameraImageUploaded": "Camera image uploaded",
-    "NotificationOptionInstallationFailed": "Installation failure",
-    "NotificationOptionNewLibraryContent": "New content added",
-    "NotificationOptionPluginError": "Plugin failure",
-    "NotificationOptionPluginInstalled": "Plugin installed",
-    "NotificationOptionPluginUninstalled": "Plugin uninstalled",
-    "NotificationOptionPluginUpdateInstalled": "Plugin update installed",
-    "NotificationOptionServerRestartRequired": "Server restart required",
-    "NotificationOptionTaskFailed": "Scheduled task failure",
-    "NotificationOptionUserLockedOut": "User locked out",
-    "NotificationOptionVideoPlayback": "Video playback started",
-    "NotificationOptionVideoPlaybackStopped": "Video playback stopped",
-    "Original": "Original",
-    "Photos": "Photos",
-    "PluginInstalledWithName": "{0} was installed",
-    "PluginUninstalledWithName": "{0} was uninstalled",
-    "PluginUpdatedWithName": "{0} was updated",
-    "ScheduledTaskFailedWithName": "{0} failed",
-    "Shows": "Shows",
-    "StartupEmbyServerIsLoading": "Jellyfin Server is loading. Please try again shortly.",
-    "SubtitleDownloadFailureFromForItem": "Subtitles failed to download from {0} to {1}",
-    "TvShows": "TV Shows",
-    "Undefined": "Undefined",
-    "UserCreatedWithName": "User {0} has been created",
-    "UserDeletedWithName": "User {0} has been deleted"
-}
diff --git a/Emby.Server.Implementations/Localization/LocalizationManager.cs b/Emby.Server.Implementations/Localization/LocalizationManager.cs
index 843e35afcc..6971431155 100644
--- a/Emby.Server.Implementations/Localization/LocalizationManager.cs
+++ b/Emby.Server.Implementations/Localization/LocalizationManager.cs
@@ -566,11 +566,15 @@ namespace Emby.Server.Implementations.Localization
 
         private static string GetResourceFilename(string culture)
         {
-            var parts = culture.Split('-');
+            // Region codes may use a '-' (BCP-47, e.g. "pt-BR") or '_' (e.g. "es_419", "ar_SA") separator.
+            // Normalize the casing (lower-case language, upper-case region) while preserving the separator
+            // so the result matches the embedded resource file name, which is case-sensitive.
+            var separatorIndex = culture.IndexOfAny(['-', '_']);
 
-            if (parts.Length == 2)
+            if (separatorIndex > 0)
             {
-                culture = parts[0].ToLowerInvariant() + "-" + parts[1].ToUpperInvariant();
+                var separator = culture[separatorIndex];
+                culture = culture[..separatorIndex].ToLowerInvariant() + separator + culture[(separatorIndex + 1)..].ToUpperInvariant();
             }
             else
             {
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
index 3b8fe5ca60..bdb726f06d 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
@@ -344,6 +344,20 @@ namespace Jellyfin.Server.Implementations.Tests.Localization
             Assert.NotEqual("Default", translated);
         }
 
+        [Fact]
+        public void GetLocalizedString_WithBcp47NormalizationToUppercaseRegion_ReturnsTranslation()
+        {
+            var localizationManager = Setup(new ServerConfiguration
+            {
+                UICulture = "en-US"
+            });
+
+            // he-IL normalizes to the underscore resource he_IL. The resource lookup is case-sensitive,
+            // so the region casing has to be preserved or the file is not found and we fall back to en-US.
+            var translated = localizationManager.GetLocalizedString("Books", "he-IL");
+            Assert.Equal("ספרים", translated);
+        }
+
         [Fact]
         public void GetServerLocalizedString_UsesServerCulture()
         {
-- 
cgit v1.2.3


From c2cb18a9d1c936d069679052aa83ef7362849d91 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 26 Jun 2026 11:42:28 +0200
Subject: Fix local plugin registration

---
 Emby.Server.Implementations/ApplicationHost.cs     | 11 +++++++++++
 .../Books/ComicServiceRegistrator.cs               | 23 ----------------------
 2 files changed, 11 insertions(+), 23 deletions(-)
 delete mode 100644 MediaBrowser.Providers/Books/ComicServiceRegistrator.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ApplicationHost.cs b/Emby.Server.Implementations/ApplicationHost.cs
index 14380c33bf..69e23bcb63 100644
--- a/Emby.Server.Implementations/ApplicationHost.cs
+++ b/Emby.Server.Implementations/ApplicationHost.cs
@@ -93,6 +93,9 @@ using MediaBrowser.Model.Net;
 using MediaBrowser.Model.Serialization;
 using MediaBrowser.Model.System;
 using MediaBrowser.Model.Tasks;
+using MediaBrowser.Providers.Books;
+using MediaBrowser.Providers.Books.ComicBookInfo;
+using MediaBrowser.Providers.Books.ComicInfo;
 using MediaBrowser.Providers.Lyric;
 using MediaBrowser.Providers.Manager;
 using MediaBrowser.Providers.Plugins.ListenBrainz;
@@ -496,6 +499,14 @@ namespace Emby.Server.Implementations
             serviceCollection.AddSingleton<ListenBrainzLabsClient>();
             serviceCollection.AddSingleton<ListenBrainzSimilarArtistProvider>();
 
+            // register the generic local metadata provider for comic files
+            serviceCollection.AddSingleton<ComicProvider>();
+
+            // register the actual implementations of the local metadata provider for comic files
+            serviceCollection.AddSingleton<IComicProvider, ComicBookInfoProvider>();
+            serviceCollection.AddSingleton<IComicProvider, ExternalComicInfoProvider>();
+            serviceCollection.AddSingleton<IComicProvider, InternalComicInfoProvider>();
+
             serviceCollection.AddSingleton(NetManager);
 
             serviceCollection.AddSingleton<ITaskManager, TaskManager>();
diff --git a/MediaBrowser.Providers/Books/ComicServiceRegistrator.cs b/MediaBrowser.Providers/Books/ComicServiceRegistrator.cs
deleted file mode 100644
index 0d096241d6..0000000000
--- a/MediaBrowser.Providers/Books/ComicServiceRegistrator.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using MediaBrowser.Controller;
-using MediaBrowser.Controller.Plugins;
-using MediaBrowser.Providers.Books.ComicBookInfo;
-using MediaBrowser.Providers.Books.ComicInfo;
-using Microsoft.Extensions.DependencyInjection;
-
-namespace MediaBrowser.Providers.Books;
-
-/// <inheritdoc />
-public class ComicServiceRegistrator : IPluginServiceRegistrator
-{
-    /// <inheritdoc />
-    public void RegisterServices(IServiceCollection serviceCollection, IServerApplicationHost applicationHost)
-    {
-        // register the generic local metadata provider for comic files
-        serviceCollection.AddSingleton<ComicProvider>();
-
-        // register the actual implementations of the local metadata provider for comic files
-        serviceCollection.AddSingleton<IComicProvider, ComicBookInfoProvider>();
-        serviceCollection.AddSingleton<IComicProvider, ExternalComicInfoProvider>();
-        serviceCollection.AddSingleton<IComicProvider, InternalComicInfoProvider>();
-    }
-}
-- 
cgit v1.2.3


From 70b45893829feddff5f5e5f89e9087b395454c08 Mon Sep 17 00:00:00 2001
From: Marc Brooks <IDisposable@gmail.com>
Date: Mon, 5 Jan 2026 18:41:34 -0600
Subject: Fix Book collections scanning all items

Added static method GetBaseItemKindsForCollectionType in ItemsController (moved from ContentFolderImageProvider to be shared)

Added AudioBook to GetRepresentativeItemTypes for CollectionType.books for consistency

Added GetBooks to GetUserItems for CollectionType.books which gets BaseItemKind.Book and BaseItemKind.AudioBook

Move GetBaseItemKindsForCollectionType to DtoExtensions

Cleaned up the missing null checks and used new collection expressions.
Associate Person to Book and AudioBook for related items.
---
 Emby.Server.Implementations/Dto/DtoService.cs      |  2 ++
 .../Images/CollectionFolderImageProvider.cs        | 42 +++-------------------
 Jellyfin.Api/Controllers/ItemsController.cs        |  3 ++
 Jellyfin.Api/Extensions/DtoExtensions.cs           | 30 ++++++++++++++++
 .../Entities/UserViewBuilder.cs                    | 14 ++++++++
 5 files changed, 53 insertions(+), 38 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 3cd72a8ac1..831419f380 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -71,6 +71,8 @@ namespace Emby.Server.Implementations.Dto
             {
                 BaseItemKind.Person, [
                     BaseItemKind.Audio,
+                    BaseItemKind.AudioBook,
+                    BaseItemKind.Book,
                     BaseItemKind.Episode,
                     BaseItemKind.Movie,
                     BaseItemKind.LiveTvProgram,
diff --git a/Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs b/Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs
index 095934f896..b701e7eb6d 100644
--- a/Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs
+++ b/Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs
@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using Jellyfin.Api.Extensions;
 using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations.Enums;
 using MediaBrowser.Common.Configuration;
@@ -14,7 +15,6 @@ using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Querying;
 
 namespace Emby.Server.Implementations.Images
 {
@@ -28,38 +28,7 @@ namespace Emby.Server.Implementations.Images
         {
             var view = (CollectionFolder)item;
             var viewType = view.CollectionType;
-
-            BaseItemKind[] includeItemTypes;
-
-            switch (viewType)
-            {
-                case CollectionType.movies:
-                    includeItemTypes = new[] { BaseItemKind.Movie };
-                    break;
-                case CollectionType.tvshows:
-                    includeItemTypes = new[] { BaseItemKind.Series };
-                    break;
-                case CollectionType.music:
-                    includeItemTypes = new[] { BaseItemKind.MusicArtist };  // Music albums usually don't have dedicated backdrops, so use artist instead
-                    break;
-                case CollectionType.musicvideos:
-                    includeItemTypes = new[] { BaseItemKind.MusicVideo };
-                    break;
-                case CollectionType.books:
-                    includeItemTypes = new[] { BaseItemKind.Book, BaseItemKind.AudioBook };
-                    break;
-                case CollectionType.boxsets:
-                    includeItemTypes = new[] { BaseItemKind.BoxSet };
-                    break;
-                case CollectionType.homevideos:
-                case CollectionType.photos:
-                    includeItemTypes = new[] { BaseItemKind.Video, BaseItemKind.Photo };
-                    break;
-                default:
-                    includeItemTypes = new[] { BaseItemKind.Video, BaseItemKind.Audio, BaseItemKind.Photo, BaseItemKind.Movie, BaseItemKind.Series };
-                    break;
-            }
-
+            var includeItemTypes = DtoExtensions.GetBaseItemKindsForCollectionType(viewType);
             var recursive = viewType != CollectionType.playlists;
 
             return view.GetItemList(new InternalItemsQuery
@@ -67,12 +36,9 @@ namespace Emby.Server.Implementations.Images
                 CollapseBoxSetItems = false,
                 Recursive = recursive,
                 DtoOptions = new DtoOptions(false),
-                ImageTypes = new[] { ImageType.Primary },
+                ImageTypes = [ImageType.Primary],
                 Limit = 8,
-                OrderBy = new[]
-                {
-                    (ItemSortBy.Random, SortOrder.Ascending)
-                },
+                OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)],
                 IncludeItemTypes = includeItemTypes
             });
         }
diff --git a/Jellyfin.Api/Controllers/ItemsController.cs b/Jellyfin.Api/Controllers/ItemsController.cs
index c52a6cd7dc..e6f59d27ec 100644
--- a/Jellyfin.Api/Controllers/ItemsController.cs
+++ b/Jellyfin.Api/Controllers/ItemsController.cs
@@ -287,6 +287,8 @@ public class ItemsController : BaseJellyfinApiController
         QueryResult<BaseItem> result;
 
         Guid[] linkedChildAncestorIds = [];
+
+        includeItemTypes ??= [];
         if (includeItemTypes.Length == 1
             && (includeItemTypes[0] == BaseItemKind.BoxSet || includeItemTypes[0] == BaseItemKind.Playlist)
             && item is not BoxSet
@@ -314,6 +316,7 @@ public class ItemsController : BaseJellyfinApiController
         if (folder is IHasCollectionType hasCollectionType)
         {
             collectionType = hasCollectionType.CollectionType;
+            includeItemTypes = [.. includeItemTypes.Union(DtoExtensions.GetBaseItemKindsForCollectionType(collectionType))];
         }
 
         if (collectionType == CollectionType.playlists)
diff --git a/Jellyfin.Api/Extensions/DtoExtensions.cs b/Jellyfin.Api/Extensions/DtoExtensions.cs
index 9c24be82ea..a6bb4f22dd 100644
--- a/Jellyfin.Api/Extensions/DtoExtensions.cs
+++ b/Jellyfin.Api/Extensions/DtoExtensions.cs
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using Jellyfin.Data.Enums;
 using MediaBrowser.Controller.Dto;
 using MediaBrowser.Model.Entities;
 
@@ -9,6 +10,35 @@ namespace Jellyfin.Api.Extensions;
 /// </summary>
 public static class DtoExtensions
 {
+    /// <summary>
+    /// Gets the BaseItemKind values associated with the specified CollectionType.
+    /// </summary>
+    /// <param name="collectionType">The collection type to map to BaseItemKind values.</param>
+    /// <returns>An array of BaseItemKind values that correspond to the collection type.</returns>
+    public static BaseItemKind[] GetBaseItemKindsForCollectionType(CollectionType? collectionType)
+    {
+        switch (collectionType)
+        {
+            case CollectionType.movies:
+                return [BaseItemKind.Movie];
+            case CollectionType.tvshows:
+                return [BaseItemKind.Series];
+            case CollectionType.music:
+                return [BaseItemKind.MusicAlbum, BaseItemKind.MusicArtist];
+            case CollectionType.musicvideos:
+                return [BaseItemKind.MusicVideo];
+            case CollectionType.books:
+                return [BaseItemKind.Book, BaseItemKind.AudioBook];
+            case CollectionType.boxsets:
+                return [BaseItemKind.BoxSet];
+            case CollectionType.homevideos:
+            case CollectionType.photos:
+                return [BaseItemKind.Video, BaseItemKind.Photo];
+            default:
+                return [BaseItemKind.Video, BaseItemKind.Audio, BaseItemKind.Photo, BaseItemKind.Movie, BaseItemKind.Series];
+        }
+    }
+
     /// <summary>
     /// Add additional DtoOptions.
     /// </summary>
diff --git a/MediaBrowser.Controller/Entities/UserViewBuilder.cs b/MediaBrowser.Controller/Entities/UserViewBuilder.cs
index cb05056601..c57ed2faf8 100644
--- a/MediaBrowser.Controller/Entities/UserViewBuilder.cs
+++ b/MediaBrowser.Controller/Entities/UserViewBuilder.cs
@@ -61,6 +61,9 @@ namespace MediaBrowser.Controller.Entities
                 case CollectionType.folders:
                     return GetResult(_libraryManager.GetUserRootFolder().GetChildren(user, true), query);
 
+                case CollectionType.books:
+                    return GetBooks(queryParent, user, query);
+
                 case CollectionType.tvshows:
                     return GetTvView(queryParent, user, query);
 
@@ -190,6 +193,17 @@ namespace MediaBrowser.Controller.Entities
             return _libraryManager.GetItemsResult(query);
         }
 
+        private QueryResult<BaseItem> GetBooks(Folder parent, User user, InternalItemsQuery query)
+        {
+            query.Recursive = true;
+            query.Parent = parent;
+            query.SetUser(user);
+
+            query.IncludeItemTypes = new[] { BaseItemKind.Book, BaseItemKind.AudioBook };
+
+            return _libraryManager.GetItemsResult(query);
+        }
+
         private QueryResult<BaseItem> GetMovieMovies(Folder parent, User user, InternalItemsQuery query)
         {
             query.Recursive = true;
-- 
cgit v1.2.3


From f2ed842b4be26966121945e7c46f00ed15023ed5 Mon Sep 17 00:00:00 2001
From: Manuel Cid <manuelcidrodriguez@gmail.com>
Date: Fri, 26 Jun 2026 12:24:57 -0400
Subject: Translated using Weblate (Galician) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/gl/

---
 Emby.Server.Implementations/Localization/Core/gl.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/gl.json b/Emby.Server.Implementations/Localization/Core/gl.json
index d3740130ee..a68db0076a 100644
--- a/Emby.Server.Implementations/Localization/Core/gl.json
+++ b/Emby.Server.Implementations/Localization/Core/gl.json
@@ -106,5 +106,6 @@
     "TaskRefreshTrickplayImages": "Xerar miniaturas de previsualización",
     "TaskAudioNormalizationDescription": "Escanea ficheiros á procura de datos de normalización de volume.",
     "CleanupUserDataTask": "Tarefa de limpeza de datos dos usuarios",
-    "CleanupUserDataTaskDescription": "Limpa todos os datos do usuario (estado de visualización, de favorito etc.) dos medios ausentes polo menos 90 días."
+    "CleanupUserDataTaskDescription": "Limpa todos os datos do usuario (estado de visualización, de favorito etc.) dos medios ausentes polo menos 90 días.",
+    "Original": "Orixinal"
 }
-- 
cgit v1.2.3


From feef2403c49003761010656cfadaba55a278acd7 Mon Sep 17 00:00:00 2001
From: Ricky Kimani <rkmacharia@outlook.com>
Date: Sun, 28 Jun 2026 03:01:20 -0400
Subject: Translated using Weblate (Swahili) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/sw/

---
 Emby.Server.Implementations/Localization/Core/sw.json | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/sw.json b/Emby.Server.Implementations/Localization/Core/sw.json
index 0967ef424b..c117a0eae2 100644
--- a/Emby.Server.Implementations/Localization/Core/sw.json
+++ b/Emby.Server.Implementations/Localization/Core/sw.json
@@ -1 +1,5 @@
-{}
+{
+    "Artists": "Wasanii",
+    "Books": "Vitabu",
+    "Collections": "Mikusanyiko"
+}
-- 
cgit v1.2.3


From dc92e3b0e489b7d6efe9ba950cbf124b84a3a4ce Mon Sep 17 00:00:00 2001
From: John Corser <johnpc@umich.edu>
Date: Sun, 19 Apr 2026 13:33:29 -0400
Subject: Fix actor images not displayed until clicked

Move image refresh logic from PeopleValidator (which runs during library
scans) into PeopleValidationTask (the "Refresh People" scheduled task).
This keeps library scans fast while ensuring the scheduled task fetches
missing images from remote providers like TMDB.

People missing a Primary image or overview get refreshed with
MetadataRefreshMode.Default instead of ValidationOnly, with a 30-day
cooldown to avoid hammering providers for people they have no data for.

Fixes jellyfin#8103
---
 .../ScheduledTasks/Tasks/PeopleValidationTask.cs   | 79 +++++++++++++++++++++-
 1 file changed, 76 insertions(+), 3 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
index 3451c458f9..0c1d004aed 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
@@ -5,8 +5,12 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Database.Implementations;
+using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
+using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Globalization;
+using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Tasks;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
@@ -21,6 +25,7 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     private readonly ILibraryManager _libraryManager;
     private readonly ILocalizationManager _localization;
     private readonly IDbContextFactory<JellyfinDbContext> _dbContextFactory;
+    private readonly IFileSystem _fileSystem;
     private readonly ILogger<PeopleValidationTask> _logger;
 
     /// <summary>
@@ -29,12 +34,19 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     /// <param name="libraryManager">Instance of the <see cref="ILibraryManager"/> interface.</param>
     /// <param name="localization">Instance of the <see cref="ILocalizationManager"/> interface.</param>
     /// <param name="dbContextFactory">Instance of the <see cref="IDbContextFactory{TContext}"/> interface.</param>
+    /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
     /// <param name="logger">Instance of the <see cref="ILogger{PeopleValidationTask}"/> interface.</param>
-    public PeopleValidationTask(ILibraryManager libraryManager, ILocalizationManager localization, IDbContextFactory<JellyfinDbContext> dbContextFactory, ILogger<PeopleValidationTask> logger)
+    public PeopleValidationTask(
+        ILibraryManager libraryManager,
+        ILocalizationManager localization,
+        IDbContextFactory<JellyfinDbContext> dbContextFactory,
+        IFileSystem fileSystem,
+        ILogger<PeopleValidationTask> logger)
     {
         _libraryManager = libraryManager;
         _localization = localization;
         _dbContextFactory = dbContextFactory;
+        _fileSystem = fileSystem;
         _logger = logger;
     }
 
@@ -83,10 +95,11 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
             return;
         }
 
+        // Phase 1: Deduplicate and remove orphaned people (0-33%)
         var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
         await using (context.ConfigureAwait(false))
         {
-            IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 2));
+            IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 3));
             var dupQuery = context.Peoples
                     .GroupBy(e => new { e.Name, e.PersonType })
                     .Where(e => e.Count() > 1)
@@ -141,9 +154,69 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
             subProgress.Report(100);
         }
 
-        IProgress<double> validateProgress = new Progress<double>((val) => progress.Report((val / 2) + 50));
+        // Phase 2: Validate people (33-66%). Runs after orphaned PeopleBaseItemMap entries are
+        // cleaned up above, so dead people are removed in a single pass instead of requiring a second run.
+        IProgress<double> validateProgress = new Progress<double>((val) => progress.Report((val / 3) + 33));
         await _libraryManager.ValidatePeopleAsync(validateProgress, cancellationToken).ConfigureAwait(false);
 
+        // Phase 3: Refresh images for people missing them (66-100%)
+        IProgress<double> refreshProgress = new Progress<double>((val) => progress.Report((val / 3) + 66));
+        await RefreshPeopleImagesAsync(refreshProgress, cancellationToken).ConfigureAwait(false);
+
         progress.Report(100);
     }
+
+    private async Task RefreshPeopleImagesAsync(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var people = _libraryManager.GetPeopleNames(new InternalPeopleQuery());
+        var numPeople = people.Count;
+        var numComplete = 0;
+        var numRefreshed = 0;
+
+        _logger.LogDebug("Checking {Count} people for missing images", numPeople);
+
+        foreach (var person in people)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                var item = _libraryManager.GetPerson(person);
+                if (item is null)
+                {
+                    continue;
+                }
+
+                var hasImage = item.HasImage(ImageType.Primary, 0);
+                var hasOverview = !string.IsNullOrWhiteSpace(item.Overview);
+
+                if ((hasImage && hasOverview) || (DateTime.UtcNow - item.DateLastRefreshed).TotalDays < 30)
+                {
+                    continue;
+                }
+
+                var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+                {
+                    ImageRefreshMode = hasImage ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default,
+                    MetadataRefreshMode = hasOverview ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default
+                };
+
+                await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
+                numRefreshed++;
+            }
+            catch (OperationCanceledException)
+            {
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "Error refreshing images for {Person}", person);
+            }
+
+            numComplete++;
+            progress.Report(100.0 * numComplete / numPeople);
+        }
+
+        _logger.LogInformation("Refreshed metadata for {Count} people missing images or overview", numRefreshed);
+    }
 }
-- 
cgit v1.2.3


From d55f80842391e1b69db927ae8938c0455ddb5192 Mon Sep 17 00:00:00 2001
From: John Corser <johnpc@umich.edu>
Date: Sat, 9 May 2026 14:11:16 -0400
Subject: Move people filtering to database query

Instead of loading all people names and checking each one in memory,
query the database directly for Person items that need refresh:
- Missing primary image OR missing overview
- Not refreshed within the last 30 days

This reduces the operation from N+1 queries (1 for all names + 1 per
person to load) to a single filtered query returning only the IDs that
need work.
---
 .../ScheduledTasks/Tasks/PeopleValidationTask.cs   | 84 ++++++++++++----------
 1 file changed, 48 insertions(+), 36 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
index 0c1d004aed..7d42693b39 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
@@ -5,6 +5,7 @@ using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
@@ -168,55 +169,66 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
 
     private async Task RefreshPeopleImagesAsync(IProgress<double> progress, CancellationToken cancellationToken)
     {
-        var people = _libraryManager.GetPeopleNames(new InternalPeopleQuery());
-        var numPeople = people.Count;
-        var numComplete = 0;
-        var numRefreshed = 0;
+        var thirtyDaysAgo = DateTime.UtcNow.AddDays(-30);
+        var personTypeName = typeof(Person).FullName!;
 
-        _logger.LogDebug("Checking {Count} people for missing images", numPeople);
-
-        foreach (var person in people)
+        var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        await using (context.ConfigureAwait(false))
         {
-            cancellationToken.ThrowIfCancellationRequested();
+            var peopleIds = await context.BaseItems
+                .AsNoTracking()
+                .Where(b => b.Type == personTypeName)
+                .Where(b => b.DateLastRefreshed == null || b.DateLastRefreshed < thirtyDaysAgo)
+                .Where(b =>
+                    !b.Images!.Any(i => i.ImageType == ImageInfoImageType.Primary) ||
+                    string.IsNullOrEmpty(b.Overview))
+                .Select(b => b.Id)
+                .ToListAsync(cancellationToken)
+                .ConfigureAwait(false);
 
-            try
+            var numPeople = peopleIds.Count;
+            var numComplete = 0;
+            var numRefreshed = 0;
+
+            _logger.LogDebug("Found {Count} people needing image/overview refresh", numPeople);
+
+            foreach (var personId in peopleIds)
             {
-                var item = _libraryManager.GetPerson(person);
-                if (item is null)
+                cancellationToken.ThrowIfCancellationRequested();
+
+                try
                 {
-                    continue;
-                }
+                    if (_libraryManager.GetItemById(personId) is not Person item)
+                    {
+                        continue;
+                    }
 
-                var hasImage = item.HasImage(ImageType.Primary, 0);
-                var hasOverview = !string.IsNullOrWhiteSpace(item.Overview);
+                    var hasImage = item.HasImage(ImageType.Primary, 0);
+                    var hasOverview = !string.IsNullOrWhiteSpace(item.Overview);
 
-                if ((hasImage && hasOverview) || (DateTime.UtcNow - item.DateLastRefreshed).TotalDays < 30)
+                    var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+                    {
+                        ImageRefreshMode = hasImage ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default,
+                        MetadataRefreshMode = hasOverview ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default
+                    };
+
+                    await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
+                    numRefreshed++;
+                }
+                catch (OperationCanceledException)
                 {
-                    continue;
+                    throw;
                 }
-
-                var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+                catch (Exception ex)
                 {
-                    ImageRefreshMode = hasImage ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default,
-                    MetadataRefreshMode = hasOverview ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default
-                };
+                    _logger.LogError(ex, "Error refreshing images for person {PersonId}", personId);
+                }
 
-                await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
-                numRefreshed++;
-            }
-            catch (OperationCanceledException)
-            {
-                throw;
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError(ex, "Error refreshing images for {Person}", person);
+                numComplete++;
+                progress.Report(100.0 * numComplete / numPeople);
             }
 
-            numComplete++;
-            progress.Report(100.0 * numComplete / numPeople);
+            _logger.LogInformation("Refreshed metadata for {Count} people missing images or overview", numRefreshed);
         }
-
-        _logger.LogInformation("Refreshed metadata for {Count} people missing images or overview", numRefreshed);
     }
 }
-- 
cgit v1.2.3


From a888257c8299026fb73c4c90160c71cdacc0ee37 Mon Sep 17 00:00:00 2001
From: John Corser <johnpc@umich.edu>
Date: Sat, 9 May 2026 14:38:22 -0400
Subject: Project hasImage/hasOverview from DB query

Instead of re-checking image/overview on the domain object after loading,
project the values directly from the database query as part of the
anonymous type selection. This avoids redundant checks since the DB
already has this information.
---
 .../ScheduledTasks/Tasks/PeopleValidationTask.cs   | 25 +++++++++++-----------
 1 file changed, 13 insertions(+), 12 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
index 7d42693b39..bdda7937fd 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
@@ -9,7 +9,6 @@ using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
-using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Globalization;
 using MediaBrowser.Model.IO;
 using MediaBrowser.Model.Tasks;
@@ -175,41 +174,43 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
         var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
         await using (context.ConfigureAwait(false))
         {
-            var peopleIds = await context.BaseItems
+            var people = await context.BaseItems
                 .AsNoTracking()
                 .Where(b => b.Type == personTypeName)
                 .Where(b => b.DateLastRefreshed == null || b.DateLastRefreshed < thirtyDaysAgo)
                 .Where(b =>
                     !b.Images!.Any(i => i.ImageType == ImageInfoImageType.Primary) ||
                     string.IsNullOrEmpty(b.Overview))
-                .Select(b => b.Id)
+                .Select(b => new
+                {
+                    b.Id,
+                    HasImage = b.Images!.Any(i => i.ImageType == ImageInfoImageType.Primary),
+                    HasOverview = !string.IsNullOrEmpty(b.Overview)
+                })
                 .ToListAsync(cancellationToken)
                 .ConfigureAwait(false);
 
-            var numPeople = peopleIds.Count;
+            var numPeople = people.Count;
             var numComplete = 0;
             var numRefreshed = 0;
 
             _logger.LogDebug("Found {Count} people needing image/overview refresh", numPeople);
 
-            foreach (var personId in peopleIds)
+            foreach (var entry in people)
             {
                 cancellationToken.ThrowIfCancellationRequested();
 
                 try
                 {
-                    if (_libraryManager.GetItemById(personId) is not Person item)
+                    if (_libraryManager.GetItemById(entry.Id) is not Person item)
                     {
                         continue;
                     }
 
-                    var hasImage = item.HasImage(ImageType.Primary, 0);
-                    var hasOverview = !string.IsNullOrWhiteSpace(item.Overview);
-
                     var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
                     {
-                        ImageRefreshMode = hasImage ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default,
-                        MetadataRefreshMode = hasOverview ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default
+                        ImageRefreshMode = entry.HasImage ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default,
+                        MetadataRefreshMode = entry.HasOverview ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default
                     };
 
                     await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
@@ -221,7 +222,7 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
                 }
                 catch (Exception ex)
                 {
-                    _logger.LogError(ex, "Error refreshing images for person {PersonId}", personId);
+                    _logger.LogError(ex, "Error refreshing images for person {PersonId}", entry.Id);
                 }
 
                 numComplete++;
-- 
cgit v1.2.3


From ef6f342a54c9c6c8713b650c4ad60005af600ade Mon Sep 17 00:00:00 2001
From: John Corser <johnpc@umich.edu>
Date: Sun, 17 May 2026 10:28:40 -0400
Subject: Use IItemTypeLookup and QueryPartitionHelpers

Address review feedback:
- Replace typeof(Person).FullName with IItemTypeLookup.BaseItemKindNames
- Replace foreach+ToListAsync with PartitionEagerAsync for batched
  iteration with built-in progress reporting
- Check HasImage/HasOverview on the loaded domain Person object
  instead of projecting from the DB query
---
 .../ScheduledTasks/Tasks/PeopleValidationTask.cs   | 102 +++++++++++++--------
 1 file changed, 65 insertions(+), 37 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
index bdda7937fd..dff9a473af 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/PeopleValidationTask.cs
@@ -4,10 +4,12 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Globalization;
 using MediaBrowser.Model.IO;
@@ -27,6 +29,7 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     private readonly IDbContextFactory<JellyfinDbContext> _dbContextFactory;
     private readonly IFileSystem _fileSystem;
     private readonly ILogger<PeopleValidationTask> _logger;
+    private readonly IItemTypeLookup _itemTypeLookup;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PeopleValidationTask" /> class.
@@ -36,18 +39,21 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     /// <param name="dbContextFactory">Instance of the <see cref="IDbContextFactory{TContext}"/> interface.</param>
     /// <param name="fileSystem">Instance of the <see cref="IFileSystem"/> interface.</param>
     /// <param name="logger">Instance of the <see cref="ILogger{PeopleValidationTask}"/> interface.</param>
+    /// <param name="itemTypeLookup">Instance of the <see cref="IItemTypeLookup"/> interface.</param>
     public PeopleValidationTask(
         ILibraryManager libraryManager,
         ILocalizationManager localization,
         IDbContextFactory<JellyfinDbContext> dbContextFactory,
         IFileSystem fileSystem,
-        ILogger<PeopleValidationTask> logger)
+        ILogger<PeopleValidationTask> logger,
+        IItemTypeLookup itemTypeLookup)
     {
         _libraryManager = libraryManager;
         _localization = localization;
         _dbContextFactory = dbContextFactory;
         _fileSystem = fileSystem;
         _logger = logger;
+        _itemTypeLookup = itemTypeLookup;
     }
 
     /// <inheritdoc />
@@ -169,60 +175,50 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
     private async Task RefreshPeopleImagesAsync(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var thirtyDaysAgo = DateTime.UtcNow.AddDays(-30);
-        var personTypeName = typeof(Person).FullName!;
+        var personTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.Person];
 
         var context = await _dbContextFactory.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
         await using (context.ConfigureAwait(false))
         {
-            var people = await context.BaseItems
+            const int PartitionSize = 100;
+
+            var numPeople = await context.BaseItems
                 .AsNoTracking()
                 .Where(b => b.Type == personTypeName)
                 .Where(b => b.DateLastRefreshed == null || b.DateLastRefreshed < thirtyDaysAgo)
                 .Where(b =>
                     !b.Images!.Any(i => i.ImageType == ImageInfoImageType.Primary) ||
                     string.IsNullOrEmpty(b.Overview))
-                .Select(b => new
-                {
-                    b.Id,
-                    HasImage = b.Images!.Any(i => i.ImageType == ImageInfoImageType.Primary),
-                    HasOverview = !string.IsNullOrEmpty(b.Overview)
-                })
-                .ToListAsync(cancellationToken)
+                .CountAsync(cancellationToken)
                 .ConfigureAwait(false);
 
-            var numPeople = people.Count;
-            var numComplete = 0;
-            var numRefreshed = 0;
-
             _logger.LogDebug("Found {Count} people needing image/overview refresh", numPeople);
 
-            foreach (var entry in people)
+            if (numPeople == 0)
             {
-                cancellationToken.ThrowIfCancellationRequested();
-
-                try
-                {
-                    if (_libraryManager.GetItemById(entry.Id) is not Person item)
-                    {
-                        continue;
-                    }
+                progress.Report(100);
+                return;
+            }
 
-                    var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
-                    {
-                        ImageRefreshMode = entry.HasImage ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default,
-                        MetadataRefreshMode = entry.HasOverview ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default
-                    };
+            var numComplete = 0;
+            var numRefreshed = 0;
 
-                    await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
-                    numRefreshed++;
-                }
-                catch (OperationCanceledException)
-                {
-                    throw;
-                }
-                catch (Exception ex)
+            await foreach (var entry in context.BaseItems
+                .AsNoTracking()
+                .Where(b => b.Type == personTypeName)
+                .Where(b => b.DateLastRefreshed == null || b.DateLastRefreshed < thirtyDaysAgo)
+                .Where(b =>
+                    !b.Images!.Any(i => i.ImageType == ImageInfoImageType.Primary) ||
+                    string.IsNullOrEmpty(b.Overview))
+                .OrderBy(b => b.Id)
+                .WithPartitionProgress(partition => _logger.LogDebug("Processing people partition {Partition}", partition))
+                .PartitionEagerAsync(PartitionSize, cancellationToken)
+                .WithCancellation(cancellationToken)
+                .ConfigureAwait(false))
+            {
+                if (await RefreshPersonAsync(entry.Id, cancellationToken).ConfigureAwait(false))
                 {
-                    _logger.LogError(ex, "Error refreshing images for person {PersonId}", entry.Id);
+                    numRefreshed++;
                 }
 
                 numComplete++;
@@ -232,4 +228,36 @@ public class PeopleValidationTask : IScheduledTask, IConfigurableScheduledTask
             _logger.LogInformation("Refreshed metadata for {Count} people missing images or overview", numRefreshed);
         }
     }
+
+    private async Task<bool> RefreshPersonAsync(Guid personId, CancellationToken cancellationToken)
+    {
+        try
+        {
+            if (_libraryManager.GetItemById(personId) is not Person item)
+            {
+                return false;
+            }
+
+            var hasImage = item.HasImage(MediaBrowser.Model.Entities.ImageType.Primary);
+            var hasOverview = !string.IsNullOrEmpty(item.Overview);
+
+            var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
+            {
+                ImageRefreshMode = hasImage ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default,
+                MetadataRefreshMode = hasOverview ? MetadataRefreshMode.ValidationOnly : MetadataRefreshMode.Default
+            };
+
+            await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
+            return true;
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Error refreshing images for person {PersonId}", personId);
+            return false;
+        }
+    }
 }
-- 
cgit v1.2.3


From 8e1b69b37f79cb55484d57ee7a90651d13538b49 Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Tue, 30 Jun 2026 14:13:04 -0400
Subject: Add missing Swedish ratings

---
 Emby.Server.Implementations/Localization/Ratings/se.json | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Ratings/se.json b/Emby.Server.Implementations/Localization/Ratings/se.json
index 70084995d1..818565e16b 100644
--- a/Emby.Server.Implementations/Localization/Ratings/se.json
+++ b/Emby.Server.Implementations/Localization/Ratings/se.json
@@ -10,7 +10,7 @@
             }
         },
         {
-            "ratingStrings": ["7"],
+            "ratingStrings": ["7", "7+", "7 År", "Från 7 år"],
             "ratingScore": {
                 "score": 7,
                 "subScore": null
@@ -31,7 +31,7 @@
             }
         },
         {
-            "ratingStrings": ["11"],
+            "ratingStrings": ["11", "11+", "11 År", "Från 11 år"],
             "ratingScore": {
                 "score": 11,
                 "subScore": null
@@ -45,11 +45,18 @@
             }
         },
         {
-            "ratingStrings": ["15"],
+            "ratingStrings": ["15", "15+", "15 År", "Från 15 år"],
             "ratingScore": {
                 "score": 15,
                 "subScore": null
             }
+        },
+        {
+            "ratingStrings": ["18", "18+", "Barnförbjuden", "Bfj"],
+            "ratingScore": {
+                "score": 18,
+                "subScore": null
+            }
         }
     ]
 }
-- 
cgit v1.2.3


From 9cc25d133dc9f41b03da6bccbfd53e1a509a86c6 Mon Sep 17 00:00:00 2001
From: m4st3r-0day <anicoku456@gmail.com>
Date: Wed, 1 Jul 2026 15:06:00 -0400
Subject: Translated using Weblate (Albanian) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/sq/

---
 Emby.Server.Implementations/Localization/Core/sq.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/sq.json b/Emby.Server.Implementations/Localization/Core/sq.json
index b1f76aafbb..e13f7b09e1 100644
--- a/Emby.Server.Implementations/Localization/Core/sq.json
+++ b/Emby.Server.Implementations/Localization/Core/sq.json
@@ -106,5 +106,7 @@
     "TaskAudioNormalization": "Normalizimi i audios",
     "TaskAudioNormalizationDescription": "Skannon skedarët për të dhëna të normalizimit të audios.",
     "CleanupUserDataTaskDescription": "Pastron të gjitha të dhënat e përdorueseve (gjendja e shikimit, statusi i të preferuarave etj.) nga mediat që nuk janë më të pranishme për të paktën 90 ditë.",
-    "CleanupUserDataTask": "Veprim për pastrimin të dhënave të përdorueseve"
+    "CleanupUserDataTask": "Veprim për pastrimin të dhënave të përdorueseve",
+    "LyricDownloadFailureFromForItem": "Teksti i këngës nuk arriti të shkarkohej nga {0} për {1}",
+    "Original": "Origjinal"
 }
-- 
cgit v1.2.3


From 38f1d9749ee67f18264937807b2f5882e1421557 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 2 Jul 2026 08:49:11 +0200
Subject: Fix review comments

---
 Emby.Server.Implementations/Dto/DtoService.cs      |  5 +-
 .../Library/MediaSourceManager.cs                  | 25 +++----
 .../Library/UserDataManager.cs                     | 20 ++---
 .../Session/SessionManager.cs                      | 11 ++-
 Emby.Server.Implementations/TV/TVSeriesManager.cs  | 20 ++---
 Jellyfin.Api/Controllers/ItemsController.cs        |  8 +-
 .../Item/BaseItemRepository.TranslateQuery.cs      | 10 ++-
 .../Item/OrderMapper.cs                            |  4 +
 .../Library/VersionPlaybackSelector.cs             | 59 +++++++++++++++
 .../Library/VersionResumeData.cs                   | 19 ++++-
 .../Library/VersionResumeDataTests.cs              | 53 ++++++++++++--
 .../Item/AlternateVersionQueryTranslationTests.cs  | 85 +++++++++++++++++++++-
 12 files changed, 259 insertions(+), 60 deletions(-)
 create mode 100644 MediaBrowser.Controller/Library/VersionPlaybackSelector.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 2bf478953e..9881565cd2 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -1272,8 +1272,9 @@ namespace Emby.Server.Implementations.Dto
                     // Match the per-user filtering of the media sources: versions the user cannot
                     // access are not selectable, so they must not count towards the badge either.
                     var mediaSourceCount = user is null
-                        ? video.MediaSourceCount
-                        : video.GetAllVersions().Count(v => v.Id.Equals(video.Id) || v.IsVisibleStandalone(user));
+                        || (!video.PrimaryVersionId.HasValue && video.LinkedAlternateVersions.Length == 0 && !video.HasLocalAlternateVersions)
+                            ? video.MediaSourceCount
+                            : video.GetAllVersions().Count(v => v.Id.Equals(video.Id) || v.IsVisibleStandalone(user));
                     if (mediaSourceCount != 1)
                     {
                         dto.MediaSourceCount = mediaSourceCount;
diff --git a/Emby.Server.Implementations/Library/MediaSourceManager.cs b/Emby.Server.Implementations/Library/MediaSourceManager.cs
index c0e45ab6c7..c64833ddaa 100644
--- a/Emby.Server.Implementations/Library/MediaSourceManager.cs
+++ b/Emby.Server.Implementations/Library/MediaSourceManager.cs
@@ -451,26 +451,23 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            MediaSourceInfo resumeSource = null;
-            UserItemData resumeData = null;
             foreach (var source in sources)
             {
-                if (source.Id is null
-                    || !dataBySourceId.TryGetValue(source.Id, out var data)
-                    || data.PlaybackPositionTicks <= 0)
+                if (source.Id is not null
+                    && dataBySourceId.TryGetValue(source.Id, out var data)
+                    && data.PlaybackPositionTicks > 0)
                 {
-                    continue;
-                }
-
-                source.PlaybackPositionTicks = data.PlaybackPositionTicks;
-
-                if (resumeData is null || (data.LastPlayedDate ?? DateTime.MinValue) > (resumeData.LastPlayedDate ?? DateTime.MinValue))
-                {
-                    resumeSource = source;
-                    resumeData = data;
+                    source.PlaybackPositionTicks = data.PlaybackPositionTicks;
                 }
             }
 
+            // Reorder only for a resumable (in-progress) version;
+            // a completed version has no position to resume, so it must not be pulled to the front here.
+            var resumeSource = VersionPlaybackSelector.SelectMostRecentlyPlayed(
+                sources,
+                source => source.Id is not null ? dataBySourceId.GetValueOrDefault(source.Id) : null,
+                data => data.PlaybackPositionTicks > 0);
+
             if (resumeSource is not null && !video.PrimaryVersionId.HasValue && !ReferenceEquals(sources[0], resumeSource))
             {
                 var reordered = new List<MediaSourceInfo>(sources.Count) { resumeSource };
diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index 61372f8b56..40cd2bb69c 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -329,21 +329,15 @@ namespace Emby.Server.Implementations.Library
 
             foreach (var (primaryId, versions) in versionGroups)
             {
-                UserItemData? resumeData = null;
-                foreach (var version in versions)
-                {
-                    // Consider both in-progress and completed versions so a finished alternate still marks the primary as played.
-                    if (userDataByVersion.TryGetValue(version.Id, out var data)
-                        && (data.PlaybackPositionTicks > 0 || data.Played)
-                        && (resumeData is null || (data.LastPlayedDate ?? DateTime.MinValue) > (resumeData.LastPlayedDate ?? DateTime.MinValue)))
-                    {
-                        resumeData = data;
-                    }
-                }
+                // Consider both in-progress and completed versions so a finished alternate still marks the primary as played.
+                var resumeVersion = VersionPlaybackSelector.SelectMostRecentlyPlayed(
+                    versions,
+                    version => userDataByVersion.GetValueOrDefault(version.Id),
+                    data => data.PlaybackPositionTicks > 0 || data.Played);
 
-                if (resumeData is not null)
+                if (resumeVersion is not null)
                 {
-                    result[primaryId] = new VersionResumeData(resumeData);
+                    result[primaryId] = new VersionResumeData(resumeVersion.Id, userDataByVersion[resumeVersion.Id]);
                 }
             }
 
diff --git a/Emby.Server.Implementations/Session/SessionManager.cs b/Emby.Server.Implementations/Session/SessionManager.cs
index 6017b7cbf6..f652634c69 100644
--- a/Emby.Server.Implementations/Session/SessionManager.cs
+++ b/Emby.Server.Implementations/Session/SessionManager.cs
@@ -980,14 +980,17 @@ namespace Emby.Server.Implementations.Session
             {
                 _userDataManager.SaveUserData(user, item, data, UserDataSaveReason.PlaybackProgress, CancellationToken.None);
 
+                // A completed version marks every alternate version played and clears their resume points, so the
+                // whole movie leaves Continue Watching and reads as watched everywhere. (Per-version resume positions
+                // only persist while nothing has been completed yet.)
                 if (data.Played == true && item is Video playedVideo)
                 {
                     playedVideo.PropagatePlayedState(user, true);
                 }
             }
 
-            if ((!user.RememberAudioSelections && data.AudioStreamIndex.HasValue)
-                || (!user.RememberSubtitleSelections && data.SubtitleStreamIndex.HasValue))
+            if ((!user.RememberAudioSelections && info.AudioStreamIndex.HasValue)
+                || (!user.RememberSubtitleSelections && info.SubtitleStreamIndex.HasValue))
             {
                 _userDataManager.ResetPlaybackStreamSelections(user, item);
             }
@@ -1177,7 +1180,9 @@ namespace Emby.Server.Implementations.Session
 
             _userDataManager.SaveUserData(user, item, data, UserDataSaveReason.PlaybackFinished, CancellationToken.None);
 
-            // A completed version marks all of its alternate versions played; positions stay per-version.
+            // A completed version marks every alternate version played and clears their resume points, so the
+            // whole movie leaves Continue Watching and reads as watched everywhere. (Per-version resume positions
+            // only persist while nothing has been completed yet.)
             if (data.Played == true && item is Video playedVideo)
             {
                 playedVideo.PropagatePlayedState(user, true);
diff --git a/Emby.Server.Implementations/TV/TVSeriesManager.cs b/Emby.Server.Implementations/TV/TVSeriesManager.cs
index 9a402a5738..459ad1a17e 100644
--- a/Emby.Server.Implementations/TV/TVSeriesManager.cs
+++ b/Emby.Server.Implementations/TV/TVSeriesManager.cs
@@ -262,19 +262,15 @@ namespace Emby.Server.Implementations.TV
                 return (null, null);
             }
 
-            Video? playedVersion = null;
-            DateTime? lastPlayedDate = null;
-            foreach (var version in lastWatchedVideo.GetAllVersions())
-            {
-                var data = _userDataManager.GetUserData(user, version);
-                if (data?.LastPlayedDate is { } date && (lastPlayedDate is null || date > lastPlayedDate))
-                {
-                    lastPlayedDate = date;
-                    playedVersion = version;
-                }
-            }
+            var versions = lastWatchedVideo.GetAllVersions();
+            var userDataByVersion = _userDataManager.GetUserDataBatch(versions, user);
+
+            var playedVersion = VersionPlaybackSelector.SelectMostRecentlyPlayed(
+                versions,
+                version => userDataByVersion.GetValueOrDefault(version.Id),
+                data => data.LastPlayedDate.HasValue);
 
-            return (playedVersion, lastPlayedDate);
+            return (playedVersion, playedVersion is null ? null : userDataByVersion[playedVersion.Id].LastPlayedDate);
         }
 
         /// <summary>
diff --git a/Jellyfin.Api/Controllers/ItemsController.cs b/Jellyfin.Api/Controllers/ItemsController.cs
index 5f23f2fcee..0c6477cd5b 100644
--- a/Jellyfin.Api/Controllers/ItemsController.cs
+++ b/Jellyfin.Api/Controllers/ItemsController.cs
@@ -963,9 +963,15 @@ public class ItemsController : BaseJellyfinApiController
         var excludeItemIds = Array.Empty<Guid>();
         if (excludeActiveSessions)
         {
+            // NowPlayingItem.Id is the displayed/primary id, but resume queries surface the actually-played
+            // alternate version's own id. Expand each active session to every version id so an in-progress
+            // alternate is excluded too, instead of leaking back into the resume list.
             excludeItemIds = _sessionManager.Sessions
                 .Where(s => s.UserId.Equals(requestUserId) && s.NowPlayingItem is not null)
-                .Select(s => s.NowPlayingItem.Id)
+                .SelectMany(s => _libraryManager.GetItemById(s.NowPlayingItem.Id) is Video video
+                    ? video.GetAllVersions().Select(v => v.Id)
+                    : [s.NowPlayingItem.Id])
+                .Distinct()
                 .ToArray();
         }
 
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
index c234f333af..ed5c353139 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.TranslateQuery.cs
@@ -556,11 +556,15 @@ public sealed partial class BaseItemRepository
                         || (e.Type != seriesTypeName && inProgressIds.Contains(e.Id)))
                     : baseQuery.Where(e => inProgressIds.Contains(e.Id));
 
-                // When several versions of the same item are in progress, keep only the most recently played one.
+                // When several versions of the same item are in progress, keep only the most recently played one, use id as tiebreaker.
                 baseQuery = baseQuery.Where(e => e.Type == seriesTypeName || !context.BaseItems
                     .Where(s => s.Id != e.Id && (s.PrimaryVersionId ?? s.Id) == (e.PrimaryVersionId ?? e.Id))
-                    .Any(s => inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
-                        > inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)));
+                    .Any(s =>
+                        inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
+                            > inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)
+                        || (inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
+                                == inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)
+                            && s.Id.CompareTo(e.Id) < 0)));
             }
             else
             {
diff --git a/Jellyfin.Server.Implementations/Item/OrderMapper.cs b/Jellyfin.Server.Implementations/Item/OrderMapper.cs
index eeeeda8193..aac85d0131 100644
--- a/Jellyfin.Server.Implementations/Item/OrderMapper.cs
+++ b/Jellyfin.Server.Implementations/Item/OrderMapper.cs
@@ -38,6 +38,10 @@ public static class OrderMapper
                 jellyfinDbContext.UserData
                     .Where(w => w.UserId == query.User.Id && (w.ItemId == e.Id || w.Item!.PrimaryVersionId == e.Id))
                     .Max(f => f.LastPlayedDate),
+            (ItemSortBy.DatePlayed, null) => e =>
+                jellyfinDbContext.UserData
+                    .Where(w => w.ItemId == e.Id || w.Item!.PrimaryVersionId == e.Id)
+                    .Max(f => f.LastPlayedDate),
             (ItemSortBy.PlayCount, _) => e => e.UserData!.Where(f => f.UserId.Equals(query.User!.Id)).OrderBy(f => f.CustomDataKey).FirstOrDefault()!.PlayCount,
             (ItemSortBy.IsFavoriteOrLiked, _) => e => e.UserData!.Where(f => f.UserId.Equals(query.User!.Id)).OrderBy(f => f.CustomDataKey).Select(f => (bool?)f.IsFavorite).FirstOrDefault() ?? false,
             (ItemSortBy.IsFolder, _) => e => e.IsFolder,
diff --git a/MediaBrowser.Controller/Library/VersionPlaybackSelector.cs b/MediaBrowser.Controller/Library/VersionPlaybackSelector.cs
new file mode 100644
index 0000000000..1766c50141
--- /dev/null
+++ b/MediaBrowser.Controller/Library/VersionPlaybackSelector.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using MediaBrowser.Controller.Entities;
+
+namespace MediaBrowser.Controller.Library
+{
+    /// <summary>
+    /// Single definition of "which alternate version was most recently played" shared by the resume tile
+    /// (<see cref="IUserDataManager.GetResumeUserData"/>), the media-source default ordering and Next Up.
+    /// Each call site declares its own eligibility rule so the intentional differences (resumable-only vs.
+    /// resumable-or-completed) are visible in one place instead of being re-implemented divergently.
+    /// The SQL resume query keeps its own translation of the same rule.
+    /// </summary>
+    public static class VersionPlaybackSelector
+    {
+        /// <summary>
+        /// Selects the entry whose user data has the greatest <see cref="UserItemData.LastPlayedDate"/>,
+        /// considering only entries that satisfy <paramref name="isEligible"/>. On an exact tie the first
+        /// encountered entry wins.
+        /// </summary>
+        /// <typeparam name="T">The candidate type (e.g. a version item or a media source).</typeparam>
+        /// <param name="items">The candidates to choose from.</param>
+        /// <param name="dataSelector">Resolves the user data for a candidate, or <c>null</c> when it has none.</param>
+        /// <param name="isEligible">Whether a candidate's user data makes it a valid winner.</param>
+        /// <returns>The most recently played eligible candidate, or <c>default</c> when none qualify.</returns>
+        public static T? SelectMostRecentlyPlayed<T>(
+            IEnumerable<T> items,
+            Func<T, UserItemData?> dataSelector,
+            Func<UserItemData, bool> isEligible)
+        {
+            ArgumentNullException.ThrowIfNull(items);
+            ArgumentNullException.ThrowIfNull(dataSelector);
+            ArgumentNullException.ThrowIfNull(isEligible);
+
+            T? winner = default;
+            var winnerDate = DateTime.MinValue;
+            var hasWinner = false;
+
+            foreach (var item in items)
+            {
+                var data = dataSelector(item);
+                if (data is null || !isEligible(data))
+                {
+                    continue;
+                }
+
+                var date = data.LastPlayedDate ?? DateTime.MinValue;
+                if (!hasWinner || date > winnerDate)
+                {
+                    winner = item;
+                    winnerDate = date;
+                    hasWinner = true;
+                }
+            }
+
+            return winner;
+        }
+    }
+}
diff --git a/MediaBrowser.Controller/Library/VersionResumeData.cs b/MediaBrowser.Controller/Library/VersionResumeData.cs
index 455fe739ce..772e2bf3a7 100644
--- a/MediaBrowser.Controller/Library/VersionResumeData.cs
+++ b/MediaBrowser.Controller/Library/VersionResumeData.cs
@@ -7,14 +7,17 @@ namespace MediaBrowser.Controller.Library
     /// <summary>
     /// The user data of the most recently played alternate version that should drive the completion state of a multi-version item.
     /// </summary>
+    /// <param name="VersionId">The id of the version that owns <paramref name="UserData"/>.</param>
     /// <param name="UserData">The resume version's user data.</param>
-    public record VersionResumeData(UserItemData UserData)
+    public record VersionResumeData(Guid VersionId, UserItemData UserData)
     {
         /// <summary>
         /// Merges the most recently played version's completion state into the supplied user data dto.
-        /// Only completion (played) propagates to the primary; the in-progress resume position stays on
-        /// the version that owns it, which is surfaced directly (e.g. in resume queries) so that playback
-        /// always targets the correct version rather than resuming the primary at another version's offset.
+        /// Completion (played) propagates to the primary. An in-progress resume position stays on the version
+        /// that owns it, which is surfaced directly (e.g. in resume queries) so that playback always targets
+        /// the correct version rather than resuming the primary at another version's offset. When the movie was
+        /// finished on a different version, the primary's own stale resume position is cleared so it does not
+        /// render as "watched and resumable" at the same time.
         /// </summary>
         /// <param name="dto">The user data dto to update.</param>
         public void ApplyTo(UserItemDataDto dto)
@@ -25,6 +28,14 @@ namespace MediaBrowser.Controller.Library
             {
                 dto.LastPlayedDate = UserData.LastPlayedDate;
             }
+
+            // A different version was finished (played, no resume position of its own) and is the most
+            // recently played: the whole movie is watched.
+            if (!VersionId.Equals(dto.ItemId) && UserData.Played && UserData.PlaybackPositionTicks <= 0)
+            {
+                dto.PlaybackPositionTicks = 0;
+                dto.PlayedPercentage = null;
+            }
         }
     }
 }
diff --git a/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs b/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
index 8642ab07f8..7d87d5ee92 100644
--- a/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
+++ b/tests/Jellyfin.Controller.Tests/Library/VersionResumeDataTests.cs
@@ -9,13 +9,14 @@ namespace Jellyfin.Controller.Tests.Library;
 public class VersionResumeDataTests
 {
     [Fact]
-    public void ApplyTo_PropagatesCompletionButNotPosition()
+    public void ApplyTo_CompletedOtherVersion_PropagatesCompletionAndClearsStaleResume()
     {
         var lastPlayed = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc);
         var resume = new VersionResumeData(
-            new UserItemData { Key = "version", PlaybackPositionTicks = 25, Played = true, LastPlayedDate = lastPlayed });
+            Guid.NewGuid(),
+            new UserItemData { Key = "version", PlaybackPositionTicks = 0, Played = true, LastPlayedDate = lastPlayed });
 
-        var dto = new UserItemDataDto { Key = "primary", PlaybackPositionTicks = 1, Played = false, PlayedPercentage = 1 };
+        var dto = new UserItemDataDto { ItemId = Guid.NewGuid(), Key = "primary", PlaybackPositionTicks = 1, Played = false, PlayedPercentage = 50 };
 
         resume.ApplyTo(dto);
 
@@ -23,9 +24,48 @@ public class VersionResumeDataTests
         Assert.True(dto.Played);
         Assert.Equal(lastPlayed, dto.LastPlayedDate);
 
-        // ...but the in-progress resume position stays on the version that owns it.
+        // ...and because the movie was finished on a different version, the primary's own stale resume bar is cleared.
+        Assert.Equal(0, dto.PlaybackPositionTicks);
+        Assert.Null(dto.PlayedPercentage);
+    }
+
+    [Fact]
+    public void ApplyTo_PrimaryOwnProgress_KeepsResumePosition()
+    {
+        var primaryId = Guid.NewGuid();
+        var lastPlayed = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc);
+
+        // The winning version is the primary itself (e.g. rewatching): its resume bar must survive.
+        var resume = new VersionResumeData(
+            primaryId,
+            new UserItemData { Key = "primary", PlaybackPositionTicks = 5, Played = true, LastPlayedDate = lastPlayed });
+
+        var dto = new UserItemDataDto { ItemId = primaryId, Key = "primary", PlaybackPositionTicks = 5, Played = true, PlayedPercentage = 20 };
+
+        resume.ApplyTo(dto);
+
+        Assert.True(dto.Played);
+        Assert.Equal(5, dto.PlaybackPositionTicks);
+        Assert.Equal(20, dto.PlayedPercentage);
+    }
+
+    [Fact]
+    public void ApplyTo_InProgressOtherVersion_KeepsPrimaryResumePosition()
+    {
+        var lastPlayed = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc);
+
+        // A different version that is in-progress (not finished) must not clear the primary's position.
+        var resume = new VersionResumeData(
+            Guid.NewGuid(),
+            new UserItemData { Key = "version", PlaybackPositionTicks = 25, Played = false, LastPlayedDate = lastPlayed });
+
+        var dto = new UserItemDataDto { ItemId = Guid.NewGuid(), Key = "primary", PlaybackPositionTicks = 1, Played = false, PlayedPercentage = 50 };
+
+        resume.ApplyTo(dto);
+
+        Assert.False(dto.Played);
         Assert.Equal(1, dto.PlaybackPositionTicks);
-        Assert.Equal(1.0, dto.PlayedPercentage);
+        Assert.Equal(50, dto.PlayedPercentage);
     }
 
     [Fact]
@@ -34,9 +74,10 @@ public class VersionResumeDataTests
         var primaryLastPlayed = new DateTime(2026, 1, 5, 0, 0, 0, DateTimeKind.Utc);
         var versionLastPlayed = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc);
         var resume = new VersionResumeData(
+            Guid.NewGuid(),
             new UserItemData { Key = "version", Played = false, LastPlayedDate = versionLastPlayed });
 
-        var dto = new UserItemDataDto { Key = "primary", Played = true, LastPlayedDate = primaryLastPlayed };
+        var dto = new UserItemDataDto { ItemId = Guid.NewGuid(), Key = "primary", Played = true, LastPlayedDate = primaryLastPlayed };
 
         resume.ApplyTo(dto);
 
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
index 1f0de153a0..c8aa14af58 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Item/AlternateVersionQueryTranslationTests.cs
@@ -61,8 +61,12 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
                 .Where(e => inProgressIds.Contains(e.Id))
                 .Where(e => !ctx.BaseItems
                     .Where(s => s.Id != e.Id && (s.PrimaryVersionId ?? s.Id) == (e.PrimaryVersionId ?? e.Id))
-                    .Any(s => inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
-                        > inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)))
+                    .Any(s =>
+                        inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
+                            > inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)
+                        || (inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
+                                == inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)
+                            && s.Id.CompareTo(e.Id) < 0)))
                 .Select(e => e.Id)
                 .ToList();
 
@@ -81,6 +85,46 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
         }
     }
 
+    [Fact]
+    public void ResumeFilter_TiedLastPlayedDate_KeepsSingleVersion()
+    {
+        Guid userId, primaryId, versionAId, versionBId;
+
+        using (var ctx = CreateDbContext())
+        {
+            (userId, primaryId, versionAId, versionBId) = SeedTiedVersions(ctx);
+        }
+
+        using (var ctx = CreateDbContext())
+        {
+            var inProgress = ctx.UserData
+                .Where(ud => ud.UserId == userId && ud.PlaybackPositionTicks > 0);
+
+            var seededIds = new[] { primaryId, versionAId, versionBId };
+            var inProgressIds = inProgress.Select(ud => ud.ItemId);
+
+            // The exact production dedup, including the Guid.CompareTo tie-break. This asserts the
+            // expression translates on SQLite and that two versions sharing an identical LastPlayedDate
+            // collapse to a single row instead of double-listing the item in Continue Watching.
+            var resumable = ctx.BaseItems
+                .Where(e => seededIds.Contains(e.Id))
+                .Where(e => inProgressIds.Contains(e.Id))
+                .Where(e => !ctx.BaseItems
+                    .Where(s => s.Id != e.Id && (s.PrimaryVersionId ?? s.Id) == (e.PrimaryVersionId ?? e.Id))
+                    .Any(s =>
+                        inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
+                            > inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)
+                        || (inProgress.Where(su => su.ItemId == s.Id).Max(su => su.LastPlayedDate)
+                                == inProgress.Where(eu => eu.ItemId == e.Id).Max(eu => eu.LastPlayedDate)
+                            && s.Id.CompareTo(e.Id) < 0)))
+                .Select(e => e.Id)
+                .ToList();
+
+            var survivor = Assert.Single(resumable);
+            Assert.Contains(survivor, new[] { versionAId, versionBId });
+        }
+    }
+
     [Fact]
     public void DatePlayedOrdering_VersionProgress_SortsPrimaryByVersionDate()
     {
@@ -136,6 +180,43 @@ public sealed class AlternateVersionQueryTranslationTests : IDisposable
         return (user.Id, primary.Id, version.Id, other.Id);
     }
 
+    private static (Guid UserId, Guid PrimaryId, Guid VersionAId, Guid VersionBId) SeedTiedVersions(JellyfinDbContext ctx)
+    {
+        var user = new User("test", "auth-provider", "reset-provider");
+        ctx.Users.Add(user);
+
+        var primary = new BaseItemEntity { Id = Guid.NewGuid(), Type = "MediaBrowser.Controller.Entities.Movies.Movie" };
+        var versionA = new BaseItemEntity { Id = Guid.NewGuid(), Type = "MediaBrowser.Controller.Entities.Movies.Movie", PrimaryVersionId = primary.Id };
+        var versionB = new BaseItemEntity { Id = Guid.NewGuid(), Type = "MediaBrowser.Controller.Entities.Movies.Movie", PrimaryVersionId = primary.Id };
+        ctx.BaseItems.AddRange(primary, versionA, versionB);
+
+        // Both versions in progress with the exact same LastPlayedDate - the tie that a strict '>' cannot break.
+        var tied = new DateTime(2026, 1, 2, 0, 0, 0, DateTimeKind.Utc);
+        ctx.UserData.Add(new UserData
+        {
+            ItemId = versionA.Id,
+            Item = versionA,
+            UserId = user.Id,
+            User = user,
+            CustomDataKey = versionA.Id.ToString("N"),
+            PlaybackPositionTicks = 1000,
+            LastPlayedDate = tied
+        });
+        ctx.UserData.Add(new UserData
+        {
+            ItemId = versionB.Id,
+            Item = versionB,
+            UserId = user.Id,
+            User = user,
+            CustomDataKey = versionB.Id.ToString("N"),
+            PlaybackPositionTicks = 2000,
+            LastPlayedDate = tied
+        });
+
+        ctx.SaveChanges();
+        return (user.Id, primary.Id, versionA.Id, versionB.Id);
+    }
+
     private JellyfinDbContext CreateDbContext()
     {
         return new JellyfinDbContext(
-- 
cgit v1.2.3


From 8f3eb3205d61d71638a1c695372cef273e76d2b3 Mon Sep 17 00:00:00 2001
From: Enea D'Angiò <enea.dangio162006@gmail.com>
Date: Thu, 2 Jul 2026 19:36:48 +0200
Subject: Close sessions for lost WebSockets to prevent zombie SyncPlay groups
 (#17079)

Close sessions for lost WebSockets to prevent zombie SyncPlay groups
---
 .../HttpServer/WebSocketConnection.cs              |   6 +-
 .../Session/SessionWebSocketListener.cs            |  15 ++-
 .../SyncPlayLostWebSocketTests.cs                  | 140 +++++++++++++++++++++
 3 files changed, 159 insertions(+), 2 deletions(-)
 create mode 100644 tests/Jellyfin.Server.Integration.Tests/SyncPlayLostWebSocketTests.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/HttpServer/WebSocketConnection.cs b/Emby.Server.Implementations/HttpServer/WebSocketConnection.cs
index e9bf3b93a7..dc7f972c13 100644
--- a/Emby.Server.Implementations/HttpServer/WebSocketConnection.cs
+++ b/Emby.Server.Implementations/HttpServer/WebSocketConnection.cs
@@ -127,8 +127,12 @@ namespace Emby.Server.Implementations.HttpServer
                 {
                     receiveResult = await _socket.ReceiveAsync(memory, cancellationToken).ConfigureAwait(false);
                 }
-                catch (WebSocketException ex)
+                catch (Exception ex) when (ex is WebSocketException or ObjectDisposedException or OperationCanceledException)
                 {
+                    // ObjectDisposedException/OperationCanceledException: the socket was torn
+                    // down underneath us (e.g. by the keep-alive watchdog after the connection
+                    // was declared lost). Fall through so Closed is still raised and the
+                    // session can release this connection.
                     _logger.LogWarning("WS {IP} error receiving data: {Message}", RemoteEndPoint, ex.Message);
                     break;
                 }
diff --git a/Emby.Server.Implementations/Session/SessionWebSocketListener.cs b/Emby.Server.Implementations/Session/SessionWebSocketListener.cs
index 6a26e92e14..2582ed9df0 100644
--- a/Emby.Server.Implementations/Session/SessionWebSocketListener.cs
+++ b/Emby.Server.Implementations/Session/SessionWebSocketListener.cs
@@ -246,8 +246,21 @@ namespace Emby.Server.Implementations.Session
                     _logger.LogInformation("Lost {0} WebSockets.", lost.Count);
                     foreach (var webSocket in lost)
                     {
-                        // TODO: handle session relative to the lost webSocket
                         RemoveWebSocket(webSocket);
+
+                        // The connection stopped answering keep-alives, so a close frame will
+                        // never arrive and the pending receive loop would hang forever, keeping
+                        // the session (and e.g. its SyncPlay group membership) alive. Disposing
+                        // the connection aborts the receive loop, which raises Closed and lets
+                        // the session end normally.
+                        try
+                        {
+                            webSocket.Dispose();
+                        }
+                        catch (Exception exception)
+                        {
+                            _logger.LogWarning(exception, "Error disposing lost WebSocket from {RemoteEndPoint}.", webSocket.RemoteEndPoint);
+                        }
                     }
                 }
             }
diff --git a/tests/Jellyfin.Server.Integration.Tests/SyncPlayLostWebSocketTests.cs b/tests/Jellyfin.Server.Integration.Tests/SyncPlayLostWebSocketTests.cs
new file mode 100644
index 0000000000..fa15b33af6
--- /dev/null
+++ b/tests/Jellyfin.Server.Integration.Tests/SyncPlayLostWebSocketTests.cs
@@ -0,0 +1,140 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Json;
+using System.Net.WebSockets;
+using System.Reflection;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Emby.Server.Implementations.Session;
+using Jellyfin.Api.Models.SyncPlayDtos;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Controller.Net;
+using Microsoft.Extensions.DependencyInjection;
+using Xunit;
+
+namespace Jellyfin.Server.Integration.Tests;
+
+public sealed class SyncPlayLostWebSocketTests : IClassFixture<JellyfinApplicationFactory>
+{
+    private readonly JellyfinApplicationFactory _factory;
+
+    public SyncPlayLostWebSocketTests(JellyfinApplicationFactory factory)
+    {
+        _factory = factory;
+    }
+
+    [Fact]
+    public async Task LostWebSocket_EndsSession_And_RemovesEmptySyncPlayGroup()
+    {
+        var cancellationToken = TestContext.Current.CancellationToken;
+        var client = _factory.CreateClient();
+        var accessToken = await AuthHelper.CompleteStartupAsync(client);
+        client.DefaultRequestHeaders.AddAuthHeader(accessToken);
+
+        var wsClient = _factory.Server.CreateWebSocketClient();
+        wsClient.ConfigureRequest = request =>
+            request.Headers.Authorization = AuthHelper.DummyAuthHeader + $", Token={accessToken}";
+
+        var webSocket = await wsClient.ConnectAsync(
+            new UriBuilder(_factory.Server.BaseAddress)
+            {
+                Scheme = "ws",
+                Path = "websocket"
+            }.Uri,
+            cancellationToken);
+
+        _ = DrainAsync(webSocket, cancellationToken);
+
+        var watched = await WaitForWatchedWebSocketsAsync(TimeSpan.FromSeconds(10), cancellationToken);
+        var connection = Assert.Single(watched);
+
+        using var createResponse = await client.PostAsync(
+            "SyncPlay/New",
+            JsonContent.Create(new NewGroupRequestDto { GroupName = "ZombieGroupRepro" }, options: JsonDefaults.Options),
+            cancellationToken);
+        Assert.Equal(HttpStatusCode.OK, createResponse.StatusCode);
+        Assert.Equal(1, await WaitForGroupCountAsync(client, 1, TimeSpan.FromSeconds(10), cancellationToken));
+
+        connection.LastKeepAliveDate = DateTime.UtcNow - TimeSpan.FromSeconds(180);
+
+        var groupCount = await WaitForGroupCountAsync(client, 0, TimeSpan.FromSeconds(45), cancellationToken);
+        Assert.True(
+            groupCount == 0,
+            $"SyncPlay group still listed {groupCount} group(s) after the WebSocket was lost: "
+            + "the keep-alive watchdog removed the socket from its watchlist without closing "
+            + "the session, leaving a zombie participant in the group (SessionWebSocketListener).");
+    }
+
+    private static async Task DrainAsync(WebSocket webSocket, CancellationToken cancellationToken)
+    {
+        var buffer = new byte[4096];
+        try
+        {
+            while (webSocket.State == WebSocketState.Open)
+            {
+                await webSocket.ReceiveAsync(buffer, cancellationToken);
+            }
+        }
+        catch
+        {
+            // The server tears the connection down once the watchdog gives up on it.
+        }
+    }
+
+    private async Task<IReadOnlyList<IWebSocketConnection>> WaitForWatchedWebSocketsAsync(TimeSpan timeout, CancellationToken cancellationToken)
+    {
+        var listener = _factory.Services.GetRequiredService<IEnumerable<IWebSocketListener>>()
+            .OfType<SessionWebSocketListener>()
+            .Single();
+        var watchlistField = typeof(SessionWebSocketListener)
+            .GetField("_webSockets", BindingFlags.NonPublic | BindingFlags.Instance);
+        Assert.NotNull(watchlistField);
+        var watchlist = (IEnumerable<IWebSocketConnection>)watchlistField.GetValue(listener)!;
+
+        var stopwatch = Stopwatch.StartNew();
+        while (true)
+        {
+            try
+            {
+                var snapshot = watchlist.ToArray();
+                if (snapshot.Length > 0 || stopwatch.Elapsed >= timeout)
+                {
+                    return snapshot;
+                }
+            }
+            catch (InvalidOperationException)
+            {
+                // The watchdog mutated the set during enumeration; retry.
+            }
+
+            await Task.Delay(100, cancellationToken);
+        }
+    }
+
+    private static async Task<int> WaitForGroupCountAsync(HttpClient client, int expected, TimeSpan timeout, CancellationToken cancellationToken)
+    {
+        var stopwatch = Stopwatch.StartNew();
+        var count = -1;
+        while (stopwatch.Elapsed < timeout)
+        {
+            using var response = await client.GetAsync("SyncPlay/List", cancellationToken);
+            response.EnsureSuccessStatusCode();
+            await using var stream = await response.Content.ReadAsStreamAsync(cancellationToken);
+            using var document = await JsonDocument.ParseAsync(stream, cancellationToken: cancellationToken);
+            count = document.RootElement.GetArrayLength();
+            if (count == expected)
+            {
+                return count;
+            }
+
+            await Task.Delay(500, cancellationToken);
+        }
+
+        return count;
+    }
+}
-- 
cgit v1.2.3


From ccc1712d10526d3a21e8136c702b84c46ac0a536 Mon Sep 17 00:00:00 2001
From: Chamithu Mapalagama <chamithuem@gmail.com>
Date: Thu, 2 Jul 2026 19:40:06 -0400
Subject: Translated using Weblate (Sinhala) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/si/

---
 Emby.Server.Implementations/Localization/Core/si.json | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/si.json b/Emby.Server.Implementations/Localization/Core/si.json
index 0967ef424b..8efc0d1f2e 100644
--- a/Emby.Server.Implementations/Localization/Core/si.json
+++ b/Emby.Server.Implementations/Localization/Core/si.json
@@ -1 +1,15 @@
-{}
+{
+    "AppDeviceValues": "ඇප්: {0}, උපාංග: {1}",
+    "Artists": "කලාකරුවන්",
+    "AuthenticationSucceededWithUserName": "{0} සාර්ථකව තහවුරු කරන ලදී",
+    "Books": "පොත්",
+    "ChapterNameValue": "{0} වෙනි පරිච්ඡේදය",
+    "Collections": "සංහිතා",
+    "Default": "පෙරනිමි",
+    "External": "බාහිර",
+    "FailedLoginAttemptWithUserName": "{0} වෙතින් සිදුකළ පිවිසීමේ උත්සාහය අසාර්ථක විය",
+    "Favorites": "ප්‍රියතමයන්",
+    "Folders": "ෆෝල්ඩර",
+    "Forced": "නියමිත",
+    "Genres": "ප්‍රභේද"
+}
-- 
cgit v1.2.3


From 43a152359ebcc6168a1d1d9d21174f14c6b9bd9b Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Fri, 3 Jul 2026 11:46:16 -0400
Subject: Fix ghost entries when deleting library paths

---
 Emby.Server.Implementations/IO/ManagedFileSystem.cs     |  2 +-
 .../Library/Resolvers/PlaylistResolver.cs               | 12 +++++++++++-
 MediaBrowser.Controller/Entities/Folder.cs              | 17 +++++++++++++----
 3 files changed, 25 insertions(+), 6 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/IO/ManagedFileSystem.cs b/Emby.Server.Implementations/IO/ManagedFileSystem.cs
index 199407044b..ede9b27592 100644
--- a/Emby.Server.Implementations/IO/ManagedFileSystem.cs
+++ b/Emby.Server.Implementations/IO/ManagedFileSystem.cs
@@ -691,7 +691,7 @@ namespace Emby.Server.Implementations.IO
             }
             catch (Exception ex) when (ex is UnauthorizedAccessException or DirectoryNotFoundException or SecurityException)
             {
-                _logger.LogError(ex, "Failed to enumerate path {Path}", path);
+                _logger.LogWarning("Failed to enumerate path \"{Path}\": {Message}", path, ex.Message);
                 return Enumerable.Empty<string>();
             }
         }
diff --git a/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs b/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
index 14798dda65..74c1f69616 100644
--- a/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
@@ -1,6 +1,7 @@
 #nullable disable
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using Jellyfin.Data.Enums;
@@ -46,7 +47,16 @@ namespace Emby.Server.Implementations.Library.Resolvers
                 }
 
                 // It's a directory-based playlist if the directory contains a playlist file
-                var filePaths = Directory.EnumerateFiles(args.Path, "*", new EnumerationOptions { IgnoreInaccessible = true });
+                IEnumerable<string> filePaths;
+                try
+                {
+                    filePaths = Directory.EnumerateFiles(args.Path, "*", new EnumerationOptions { IgnoreInaccessible = true });
+                }
+                catch (IOException)
+                {
+                    return null;
+                }
+
                 if (filePaths.Any(f => f.EndsWith(PlaylistXmlSaver.DefaultPlaylistFilename, StringComparison.OrdinalIgnoreCase)))
                 {
                     return new Playlist
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index 25cbcedc5f..b1f7f29bad 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -384,6 +384,7 @@ namespace MediaBrowser.Controller.Entities
             cancellationToken.ThrowIfCancellationRequested();
 
             var validChildren = new List<BaseItem>();
+            var accessibleChildren = new List<BaseItem>();
             var validChildrenNeedGeneration = false;
 
             if (IsFileProtocol)
@@ -438,12 +439,19 @@ namespace MediaBrowser.Controller.Entities
                 {
                     if (!IsLibraryFolderAccessible(directoryService, child, allowRemoveRoot))
                     {
+                        // Preserve inaccessible items so they aren't treated as removed.
+                        if (currentChildren.TryGetValue(child.Id, out var childrenToKeep))
+                        {
+                            validChildren.Add(childrenToKeep);
+                        }
+
                         continue;
                     }
 
                     if (currentChildren.TryGetValue(child.Id, out BaseItem currentChild))
                     {
                         validChildren.Add(currentChild);
+                        accessibleChildren.Add(currentChild);
 
                         if (currentChild.UpdateFromResolvedItem(child) > ItemUpdateType.None)
                         {
@@ -480,11 +488,12 @@ namespace MediaBrowser.Controller.Entities
                     child.SetParent(this);
                     newItems.Add(child);
                     validChildren.Add(child);
+                    accessibleChildren.Add(child);
                 }
 
                 // That's all the new and changed ones - now see if any have been removed and need cleanup
                 var itemsRemoved = currentChildren.Values.Except(validChildren).ToList();
-                var shouldRemove = !IsRoot || allowRemoveRoot;
+
                 // If it's an AggregateFolder, don't remove
                 // Collect replaced primaries for deferred deletion (after CreateItems)
                 var replacedPrimaries = new List<(Video OldPrimary, Video NewPrimary)>();
@@ -497,7 +506,7 @@ namespace MediaBrowser.Controller.Entities
                     .Where(p => !string.IsNullOrEmpty(p))
                     .ToHashSet(StringComparer.OrdinalIgnoreCase);
 
-                if (shouldRemove && itemsRemoved.Count > 0)
+                if (itemsRemoved.Count > 0)
                 {
                     foreach (var item in itemsRemoved)
                     {
@@ -703,7 +712,7 @@ namespace MediaBrowser.Controller.Entities
                     validChildrenNeedGeneration = false;
                 }
 
-                await ValidateSubFolders(validChildren.OfType<Folder>().ToList(), directoryService, innerProgress, cancellationToken).ConfigureAwait(false);
+                await ValidateSubFolders(accessibleChildren.OfType<Folder>().ToList(), directoryService, innerProgress, cancellationToken).ConfigureAwait(false);
             }
 
             if (refreshChildMetadata)
@@ -742,7 +751,7 @@ namespace MediaBrowser.Controller.Entities
                         validChildren = Children.ToList();
                     }
 
-                    await RefreshMetadataRecursive(validChildren, refreshOptions, recursive, innerProgress, cancellationToken).ConfigureAwait(false);
+                    await RefreshMetadataRecursive(accessibleChildren, refreshOptions, recursive, innerProgress, cancellationToken).ConfigureAwait(false);
                 }
             }
         }
-- 
cgit v1.2.3


From 4b5f5d6ca3e5b2fe4638cf18a107f39b49cc940d Mon Sep 17 00:00:00 2001
From: Ulrik <ulrik.johansen@me.com>
Date: Sat, 4 Jul 2026 14:36:40 -0400
Subject: Translated using Weblate (Danish) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/da/

---
 Emby.Server.Implementations/Localization/Core/da.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/da.json b/Emby.Server.Implementations/Localization/Core/da.json
index 697d9c090f..22ecbb96b9 100644
--- a/Emby.Server.Implementations/Localization/Core/da.json
+++ b/Emby.Server.Implementations/Localization/Core/da.json
@@ -65,7 +65,7 @@
     "TaskDownloadMissingSubtitlesDescription": "Søger på internettet efter manglende undertekster baseret på metadata-konfigurationen.",
     "TaskDownloadMissingSubtitles": "Hent manglende undertekster",
     "TaskUpdatePluginsDescription": "Henter og installerer opdateringer for plugins, som er konfigurerede til at blive opdateret automatisk.",
-    "TaskUpdatePlugins": "Opdater plugins",
+    "TaskUpdatePlugins": "Opdatér plugins",
     "TaskCleanLogsDescription": "Sletter log-filer som er mere end {0} dage gamle.",
     "TaskCleanLogs": "Ryd log-mappe",
     "TaskRefreshLibraryDescription": "Scanner dit mediebibliotek for nye filer og opdateret metadata.",
@@ -79,10 +79,10 @@
     "TaskRefreshChapterImages": "Udtræk kapitelbilleder",
     "TaskRefreshChapterImagesDescription": "Laver miniaturebilleder for videoer, der har kapitler.",
     "TaskRefreshChannelsDescription": "Opdaterer information for internetkanaler.",
-    "TaskRefreshChannels": "Opdater kanaler",
+    "TaskRefreshChannels": "Opdatér kanaler",
     "TaskCleanTranscodeDescription": "Fjerner omkodningsfiler, som er mere end 1 dag gamle.",
     "TaskCleanTranscode": "Tøm omkodningsmappen",
-    "TaskRefreshPeople": "Opdater personer",
+    "TaskRefreshPeople": "Opdatér personer",
     "TaskRefreshPeopleDescription": "Opdaterer metadata for skuespillere og instruktører i dit mediebibliotek.",
     "TaskCleanActivityLogDescription": "Sletter linjer i aktivitetsloggen ældre end den konfigurerede alder.",
     "TaskCleanActivityLog": "Ryd aktivitetslog",
@@ -90,7 +90,7 @@
     "Forced": "Tvunget",
     "Default": "Standard",
     "TaskOptimizeDatabaseDescription": "Komprimerer databasen for at frigøre plads. Denne handling køres efter at have scannet mediebiblioteket, eller efter at have lavet ændringer til databasen.",
-    "TaskOptimizeDatabase": "Optimer database",
+    "TaskOptimizeDatabase": "Optimér database",
     "TaskKeyframeExtractorDescription": "Udtrækker rammer fra videofiler for at lave mere præcise HLS-playlister. Denne opgave kan tage lang tid.",
     "TaskKeyframeExtractor": "Udtræk nøglerammer",
     "External": "Ekstern",
-- 
cgit v1.2.3


From 2528bc10326e4b842899b55ae2d023414f5fc53f Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Sat, 4 Jul 2026 17:53:55 -0400
Subject: Fix parental rating lookup for multi-rating entries

---
 .../Localization/LocalizationManager.cs             | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/LocalizationManager.cs b/Emby.Server.Implementations/Localization/LocalizationManager.cs
index 6971431155..98f629d31c 100644
--- a/Emby.Server.Implementations/Localization/LocalizationManager.cs
+++ b/Emby.Server.Implementations/Localization/LocalizationManager.cs
@@ -356,6 +356,27 @@ namespace Emby.Server.Implementations.Localization
         {
             ArgumentException.ThrowIfNullOrEmpty(rating);
 
+            // Some providers may list multiple ratings separated by '/' (e.g. "SE:15 / SE:15+ / SE:Från 15 år").
+            // Try each one in order and use the first that resolves.
+            var ratingValues = rating.Split('/', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+
+            foreach (var ratingValue in ratingValues)
+            {
+                var score = GetSingleRatingScore(ratingValue, countryCode);
+                if (score is not null)
+                {
+                    return score;
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Resolves a single rating value to a score.
+        /// </summary>
+        private ParentalRatingScore? GetSingleRatingScore(string rating, string? countryCode)
+        {
             // Handle unrated content
             if (_unratedValues.Contains(rating.AsSpan(), StringComparison.OrdinalIgnoreCase))
             {
-- 
cgit v1.2.3


From 381bf181616c2294b739b97df6c0fa062dbd25c9 Mon Sep 17 00:00:00 2001
From: Lofuuzi <lather0519@gmail.com>
Date: Sun, 5 Jul 2026 03:36:57 -0400
Subject: Translated using Weblate (Chinese (Traditional Han script, Hong
 Kong)) Translation: Jellyfin/Jellyfin Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/zh_Hant_HK/

---
 Emby.Server.Implementations/Localization/Core/zh-HK.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/zh-HK.json b/Emby.Server.Implementations/Localization/Core/zh-HK.json
index 1098880cf3..1a4b2fd53a 100644
--- a/Emby.Server.Implementations/Localization/Core/zh-HK.json
+++ b/Emby.Server.Implementations/Localization/Core/zh-HK.json
@@ -78,7 +78,7 @@
     "TaskCleanLogs": "清理日誌資料夾",
     "TaskRefreshLibrary": "掃描媒體櫃",
     "TaskRefreshChapterImagesDescription": "幫有章節嘅影片整返啲章節縮圖。",
-    "TaskRefreshChapterImages": "擷取章節圖片",
+    "TaskRefreshChapterImages": "擷取章節圖像",
     "TaskCleanCacheDescription": "刪走系統已經唔再需要嘅快取檔案。",
     "TaskCleanCache": "清理快取（Cache）資料夾",
     "TasksChannelsCategory": "網路頻道",
-- 
cgit v1.2.3


From 7f5537ca47dce098dbebb6545083afec86364b4d Mon Sep 17 00:00:00 2001
From: Ulrik <ulrik.johansen@me.com>
Date: Sun, 5 Jul 2026 11:03:06 -0400
Subject: Translated using Weblate (Danish) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/da/

---
 Emby.Server.Implementations/Localization/Core/da.json | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/da.json b/Emby.Server.Implementations/Localization/Core/da.json
index 22ecbb96b9..de56b6fd66 100644
--- a/Emby.Server.Implementations/Localization/Core/da.json
+++ b/Emby.Server.Implementations/Localization/Core/da.json
@@ -9,7 +9,7 @@
     "Favorites": "Favoritter",
     "Folders": "Mapper",
     "Genres": "Genrer",
-    "HeaderContinueWatching": "Fortsæt afspilning",
+    "HeaderContinueWatching": "Fortsæt med at se",
     "HeaderFavoriteEpisodes": "Yndlingsafsnit",
     "HeaderFavoriteShows": "Yndlingsserier",
     "HeaderLiveTV": "Live-TV",
@@ -99,7 +99,7 @@
     "TaskRefreshTrickplayImagesDescription": "Laver trickplay-billeder for videoer i aktiverede biblioteker.",
     "TaskAudioNormalizationDescription": "Skanner filer for data vedrørende lydnormalisering.",
     "TaskAudioNormalization": "Lydnormalisering",
-    "TaskDownloadMissingLyricsDescription": "Søger på internettet efter manglende sangtekster baseret på metadata-konfigurationen",
+    "TaskDownloadMissingLyricsDescription": "Download sangtekster",
     "TaskDownloadMissingLyrics": "Hent manglende sangtekster",
     "TaskExtractMediaSegments": "Scan for mediesegmenter",
     "TaskMoveTrickplayImages": "Migrer billedelokationer for trickplay-billeder",
-- 
cgit v1.2.3


From e31f168e9bc132b4f830e39b0781cac550c08b85 Mon Sep 17 00:00:00 2001
From: Lofuuzi <lather0519@gmail.com>
Date: Mon, 6 Jul 2026 03:59:03 -0400
Subject: Translated using Weblate (Chinese (Traditional Han script, Hong
 Kong)) Translation: Jellyfin/Jellyfin Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/zh_Hant_HK/

---
 Emby.Server.Implementations/Localization/Core/zh-HK.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/zh-HK.json b/Emby.Server.Implementations/Localization/Core/zh-HK.json
index 1a4b2fd53a..b2fcbc93a2 100644
--- a/Emby.Server.Implementations/Localization/Core/zh-HK.json
+++ b/Emby.Server.Implementations/Localization/Core/zh-HK.json
@@ -77,7 +77,7 @@
     "TaskCleanLogsDescription": "自動刪走超過 {0} 日嘅紀錄檔。",
     "TaskCleanLogs": "清理日誌資料夾",
     "TaskRefreshLibrary": "掃描媒體櫃",
-    "TaskRefreshChapterImagesDescription": "幫有章節嘅影片整返啲章節縮圖。",
+    "TaskRefreshChapterImagesDescription": "幫有章節嘅影片整返啲章節預覽圖。",
     "TaskRefreshChapterImages": "擷取章節圖像",
     "TaskCleanCacheDescription": "刪走系統已經唔再需要嘅快取檔案。",
     "TaskCleanCache": "清理快取（Cache）資料夾",
-- 
cgit v1.2.3


From 974038e9b0fc5ec9e4f6448af6f32d70c63d6e31 Mon Sep 17 00:00:00 2001
From: yuuta0331 <miyagi.hiroshi@taupe.plala.or.jp>
Date: Mon, 6 Jul 2026 18:46:02 -0400
Subject: Translated using Weblate (Japanese) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/ja/

---
 Emby.Server.Implementations/Localization/Core/ja.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/ja.json b/Emby.Server.Implementations/Localization/Core/ja.json
index 39e5af717c..78b7ec744b 100644
--- a/Emby.Server.Implementations/Localization/Core/ja.json
+++ b/Emby.Server.Implementations/Localization/Core/ja.json
@@ -106,5 +106,7 @@
     "TaskDownloadMissingLyrics": "失われた歌詞をダウンロード",
     "TaskExtractMediaSegmentsDescription": "MediaSegment 対応プラグインからメディア セグメントを抽出または取得します。",
     "CleanupUserDataTask": "ユーザーデータのクリーンアップタスク",
-    "CleanupUserDataTaskDescription": "90日以上存在しないメディアに対して、視聴状態やお気に入り状態などのユーザーデータをすべて削除します。"
+    "CleanupUserDataTaskDescription": "90日以上存在しないメディアに対して、視聴状態やお気に入り状態などのユーザーデータをすべて削除します。",
+    "LyricDownloadFailureFromForItem": "歌詞",
+    "Original": "オリジナル"
 }
-- 
cgit v1.2.3


From 1294990f4fa93b30ec9699d18af4de1cd1d562b8 Mon Sep 17 00:00:00 2001
From: Jakub Schmidtke <sjakub@gmail.com>
Date: Tue, 7 Jul 2026 04:18:02 +0200
Subject: Added more aliases for attributes

Adds tvdb alias for tvdbid and imdb alias for imdbid.

It also fixes an issue where tmdb alias was being ignored
if it was followed by something like "tmdbidfoo".
The same issue prevented imdb pattern matching from
working, if it was followed by something like "imdbidfoo".

It also allows for detecting the first matching occurence,
whether it was an alias or not.

Finally, it ignores attributes with values consisting of only whitespaces.
---
 .../Library/PathExtensions.cs                      | 81 +++++++++++++++-------
 .../Library/PathExtensionsTests.cs                 | 63 ++++++++++++++++-
 2 files changed, 118 insertions(+), 26 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/PathExtensions.cs b/Emby.Server.Implementations/Library/PathExtensions.cs
index 7591359ea4..8815e2785a 100644
--- a/Emby.Server.Implementations/Library/PathExtensions.cs
+++ b/Emby.Server.Implementations/Library/PathExtensions.cs
@@ -29,17 +29,41 @@ namespace Emby.Server.Implementations.Library
                 throw new ArgumentException("String can't be empty.", nameof(attribute));
             }
 
-            var attributeIndex = str.IndexOf(attribute, StringComparison.OrdinalIgnoreCase);
+            // Allow tmdb as an alias for tmdbid, tvdb for tvdbid, etc.
+            // The code below only supports aliases for attributes in the form of "<alias>id".
+            ReadOnlySpan<char> shortAttr = attribute switch
+            {
+                _ when attribute.Equals("tmdbid", StringComparison.OrdinalIgnoreCase) => "tmdb",
+                _ when attribute.Equals("tvdbid", StringComparison.OrdinalIgnoreCase) => "tvdb",
+                _ when attribute.Equals("imdbid", StringComparison.OrdinalIgnoreCase) => "imdb",
+                _ => string.Empty
+            };
 
-            // Must be at least 3 characters after the attribute =, ], any character,
-            // then we offset it by 1, because we want the index and not length.
-            var maxIndex = str.Length - attribute.Length - 2;
-            while (attributeIndex > -1 && attributeIndex < maxIndex)
+            for (int strIndex = 0, attributeIndex = 0; attributeIndex > -1;)
             {
-                var attributeEnd = attributeIndex + attribute.Length;
+                // We may want to use imdbid pattern matching later, so we don't want to modify the original 'str'.
+                var subStr = str[strIndex..];
+                int attributeEnd = 0;
+
+                if (shortAttr.Length > 0)
+                {
+                    // If we are using an alias it should be shorter (and a prefix), so let's search for that.
+                    attributeIndex = subStr.IndexOf(shortAttr, StringComparison.OrdinalIgnoreCase);
+                    attributeEnd = attributeIndex + shortAttr.Length;
+                }
+                else
+                {
+                    attributeIndex = subStr.IndexOf(attribute, StringComparison.OrdinalIgnoreCase);
+                    attributeEnd = attributeIndex + attribute.Length;
+                }
+
+                // The next iteration should start at the end of the attribute we just found.
+                // If attributeIndex < 0, the loop will end and strIndex won't be used again.
+                strIndex += attributeEnd;
+
                 if (attributeIndex > 0)
                 {
-                    var attributeOpener = str[attributeIndex - 1];
+                    var attributeOpener = subStr[attributeIndex - 1];
                     var attributeCloser = attributeOpener switch
                     {
                         '[' => ']',
@@ -47,20 +71,37 @@ namespace Emby.Server.Implementations.Library
                         '{' => '}',
                         _ => '\0'
                     };
-                    if (attributeCloser != '\0' && (str[attributeEnd] == '=' || str[attributeEnd] == '-'))
+
+                    if (attributeCloser != '\0')
                     {
-                        var closingIndex = str[attributeEnd..].IndexOf(attributeCloser);
+                        if (shortAttr.Length > 0
+                            && attributeEnd + 1 < subStr.Length
+                            && (subStr[attributeEnd] is 'i' or 'I')
+                            && (subStr[attributeEnd + 1] is 'd' or 'D'))
+                        {
+                            // We were searching for a shortened attribute, but it's followed by "id" - let's skip it.
+                            attributeEnd += 2;
+                        }
 
-                        // Must be at least 1 character before the closing bracket.
-                        if (closingIndex > 1)
+                        // attributeEnd points at '='.
+                        // We need at least 1 more character and the closing bracket after that.
+                        if (attributeEnd + 2 < subStr.Length && (subStr[attributeEnd] is '=' or '-'))
                         {
-                            return str[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim().ToString();
+                            var closingIndex = subStr[attributeEnd..].IndexOf(attributeCloser);
+
+                            // Must be at least 1 character before the closing bracket.
+                            if (closingIndex > 1)
+                            {
+                                var trimmed = subStr[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim();
+
+                                if (trimmed.Length > 0)
+                                {
+                                    return trimmed.ToString();
+                                }
+                            }
                         }
                     }
                 }
-
-                str = str[attributeEnd..];
-                attributeIndex = str.IndexOf(attribute, StringComparison.OrdinalIgnoreCase);
             }
 
             // for imdbid we also accept pattern matching
@@ -70,16 +111,6 @@ namespace Emby.Server.Implementations.Library
                 return match ? imdbId.ToString() : null;
             }
 
-            // Allow tmdb as an alias for tmdbid
-            if (attribute.Equals("tmdbid", StringComparison.OrdinalIgnoreCase))
-            {
-                var tmdbValue = str.GetAttributeValue("tmdb");
-                if (tmdbValue is not null)
-                {
-                    return tmdbValue;
-                }
-            }
-
             return null;
         }
 
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
index 650d67b195..e65bc1d31f 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
@@ -9,44 +9,105 @@ namespace Jellyfin.Server.Implementations.Tests.Library
     {
         [Theory]
         [InlineData("Superman: Red Son [imdbid=tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son [imdb=tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son [imdbid-tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son [imdb-tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son - tt10985510", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son {imdbid=tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son {imdb=tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son {imdbid-tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son {imdb-tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (imdbid=tt10985510)", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (imdb=tt10985510)", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son (imdbid-tt10985510)", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (imdb-tt10985510)", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son", "imdbid", null)]
         [InlineData("Superman: Red Son [imdbid1=tt11111111][imdbid=tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son [imdbid1=tt11111111][imdb=tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son {imdbid1=tt11111111}(imdbid=tt10985510)", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son {imdbid1=tt11111111}(imdb=tt10985510)", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son (imdbid1-tt11111111)[imdbid=tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (imdbid1-tt11111111)[imdb=tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son [tmdbid=618355][imdbid=tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son [tmdbid=618355][imdb=tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son [tmdbid-618355]{imdbid-tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son [tmdbid-618355]{imdb-tt10985510}", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son (tmdbid-618355)[imdbid-tt10985510]", "tmdbid", "618355")]
+        [InlineData("Superman: Red Son (tmdbid-618355)[imdb-tt10985510]", "tmdbid", "618355")]
         [InlineData("Superman: Red Son [providera-id=1]", "providera-id", "1")]
         [InlineData("Superman: Red Son [providerb-id=2]", "providerb-id", "2")]
         [InlineData("Superman: Red Son [providera id=4]", "providera id", "4")]
         [InlineData("Superman: Red Son [providerb id=5]", "providerb id", "5")]
+        [InlineData("Superman: Red Son [provider=99][providerid=5]", "providerid", "5")]
         [InlineData("Superman: Red Son [tmdbid=3]", "tmdbid", "3")]
-        [InlineData("Superman: Red Son [tvdbid-6]", "tvdbid", "6")]
+        [InlineData("Superman: Red Son [tmdb=3]", "tmdbid", "3")]
+        [InlineData("Superman: Red Son [tmdbid-3]", "tmdbid", "3")]
+        [InlineData("Superman: Red Son [tmdb-3]", "tmdbid", "3")]
         [InlineData("Superman: Red Son {tmdbid=3}", "tmdbid", "3")]
+        [InlineData("Superman: Red Son {tmdb=3}", "tmdbid", "3")]
+        [InlineData("Superman: Red Son {tmdbid-3}", "tmdbid", "3")]
+        [InlineData("Superman: Red Son {tmdb-3}", "tmdbid", "3")]
+        [InlineData("Superman: Red Son (tmdbid=6)", "tmdbid", "6")]
+        [InlineData("Superman: Red Son (tmdb=6)", "tmdbid", "6")]
+        [InlineData("Superman: Red Son (tmdbid-6)", "tmdbid", "6")]
+        [InlineData("Superman: Red Son (tmdb-6)", "tmdbid", "6")]
+        [InlineData("Superman: Red Son [tvdbid=6]", "tvdbid", "6")]
+        [InlineData("Superman: Red Son [tvdb=6]", "tvdbid", "6")]
+        [InlineData("Superman: Red Son [tvdbid-6]", "tvdbid", "6")]
+        [InlineData("Superman: Red Son [tvdb-6]", "tvdbid", "6")]
+        [InlineData("Superman: Red Son {tvdbid=3}", "tvdbid", "3")]
+        [InlineData("Superman: Red Son {tvdb=3}", "tvdbid", "3")]
+        [InlineData("Superman: Red Son {tvdbid-3}", "tvdbid", "3")]
+        [InlineData("Superman: Red Son {tvdb-3}", "tvdbid", "3")]
+        [InlineData("Superman: Red Son (tvdbid=6)", "tvdbid", "6")]
+        [InlineData("Superman: Red Son (tvdb=6)", "tvdbid", "6")]
         [InlineData("Superman: Red Son (tvdbid-6)", "tvdbid", "6")]
+        [InlineData("Superman: Red Son (tvdb-6)", "tvdbid", "6")]
         [InlineData("[tmdbid=618355]", "tmdbid", "618355")]
+        [InlineData("[tmdb=618355]", "tmdbid", "618355")]
         [InlineData("{tmdbid=618355}", "tmdbid", "618355")]
+        [InlineData("{tmdb=618355}", "tmdbid", "618355")]
         [InlineData("(tmdbid=618355)", "tmdbid", "618355")]
+        [InlineData("(tmdb=618355)", "tmdbid", "618355")]
         [InlineData("[tmdbid-618355]", "tmdbid", "618355")]
+        [InlineData("[tmdb-618355]", "tmdbid", "618355")]
         [InlineData("{tmdbid-618355)", "tmdbid", null)]
+        [InlineData("{tmdb-618355)", "tmdbid", null)]
         [InlineData("[tmdbid-618355}", "tmdbid", null)]
+        [InlineData("[tmdb-618355}", "tmdbid", null)]
         [InlineData("tmdbid=111111][tmdbid=618355]", "tmdbid", "618355")]
+        [InlineData("tmdbid=111111][tmdb=618355]", "tmdbid", "618355")]
         [InlineData("[tmdbid=618355]tmdbid=111111]", "tmdbid", "618355")]
+        [InlineData("[tmdb=618355]tmdbid=111111]", "tmdbid", "618355")]
         [InlineData("tmdbid=618355]", "tmdbid", null)]
+        [InlineData("tmdb=618355]", "tmdbid", null)]
         [InlineData("[tmdbid=618355", "tmdbid", null)]
+        [InlineData("[tmdb=618355", "tmdbid", null)]
         [InlineData("tmdbid=618355", "tmdbid", null)]
+        [InlineData("tmdb=618355", "tmdbid", null)]
         [InlineData("tmdbid=", "tmdbid", null)]
+        [InlineData("tmdb=", "tmdbid", null)]
         [InlineData("tmdbid", "tmdbid", null)]
+        [InlineData("tmdb", "tmdbid", null)]
+        [InlineData("[tmdbid= ][tmdbid=223344]", "tmdbid", "223344")]
+        [InlineData("[tmdb= ][tmdb=223344]", "tmdbid", "223344")]
+        [InlineData("[tmdbid=  ][tmdb=223344]", "tmdbid", "223344")]
+        [InlineData("[tmdb=   ][tmdbid=223344]", "tmdbid", "223344")]
         [InlineData("[tmdbid=][imdbid=tt10985510]", "tmdbid", null)]
+        [InlineData("[tmdb=][imdbid=tt10985510]", "tmdbid", null)]
         [InlineData("[tmdbid-][imdbid-tt10985510]", "tmdbid", null)]
+        [InlineData("[tmdb-][imdbid-tt10985510]", "tmdbid", null)]
         [InlineData("Superman: Red Son [tmdbid-618355][tmdbid=1234567]", "tmdbid", "618355")]
+        [InlineData("Superman: Red Son [tmdb-618355][tmdbid=1234567]", "tmdbid", "618355")]
         [InlineData("{tmdbid=}{imdbid=tt10985510}", "tmdbid", null)]
+        [InlineData("{tmdb=}{imdbid=tt10985510}", "tmdbid", null)]
         [InlineData("(tmdbid-)(imdbid-tt10985510)", "tmdbid", null)]
+        [InlineData("(tmdb-)(imdbid-tt10985510)", "tmdbid", null)]
         [InlineData("Superman: Red Son {tmdbid-618355}{tmdbid=1234567}", "tmdbid", "618355")]
+        [InlineData("Superman: Red Son {tmdb-618355}{tmdbid=1234567}", "tmdbid", "618355")]
+        [InlineData("Superman: Red Son - tt10985510 [imdbid1=tt11]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son [tmdb=618355][tmdbid1=1]", "tmdbid", "618355")]
+        [InlineData("Superman: Red Son [tmdb=618355][tmdbid=12345]", "tmdbid", "618355")]
         public void GetAttributeValue_ValidArgs_Correct(string input, string attribute, string? expectedResult)
         {
             Assert.Equal(expectedResult, PathExtensions.GetAttributeValue(input, attribute));
-- 
cgit v1.2.3


From fff710585f924ce8c868e6706373155a3bcf6444 Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Tue, 7 Jul 2026 10:03:17 -0400
Subject: Restore music collection image override

---
 Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs b/Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs
index b701e7eb6d..7cae2a671b 100644
--- a/Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs
+++ b/Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs
@@ -31,6 +31,12 @@ namespace Emby.Server.Implementations.Images
             var includeItemTypes = DtoExtensions.GetBaseItemKindsForCollectionType(viewType);
             var recursive = viewType != CollectionType.playlists;
 
+            if (viewType == CollectionType.music)
+            {
+                // Music albums usually don't have dedicated backdrops, so use artist instead
+                includeItemTypes = [BaseItemKind.MusicArtist];
+            }
+
             return view.GetItemList(new InternalItemsQuery
             {
                 CollapseBoxSetItems = false,
-- 
cgit v1.2.3


From d73e65172a0f5fbe942ed4289e90d6e4c983232c Mon Sep 17 00:00:00 2001
From: Shed Shedson <hjorturthorgeirs+hmp1devq@gmail.com>
Date: Tue, 7 Jul 2026 12:30:00 -0400
Subject: Translated using Weblate (Icelandic) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/is/

---
 Emby.Server.Implementations/Localization/Core/is.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/is.json b/Emby.Server.Implementations/Localization/Core/is.json
index c9ca00afdf..5efc241638 100644
--- a/Emby.Server.Implementations/Localization/Core/is.json
+++ b/Emby.Server.Implementations/Localization/Core/is.json
@@ -103,5 +103,7 @@
     "TaskDownloadMissingLyrics": "Sækja söngtexta sem vantar",
     "TaskExtractMediaSegments": "Skönnun efnishluta",
     "CleanupUserDataTask": "Hreinsun notendagagna",
-    "CleanupUserDataTaskDescription": "Hreinsar öll notendagögn (spilunarstöðu, uppáhöld o.s.frv.) um gögn sem hafa ekki verið til staðar í að lámarki 90 daga."
+    "CleanupUserDataTaskDescription": "Hreinsar öll notendagögn (spilunarstöðu, uppáhöld o.s.frv.) um gögn sem hafa ekki verið til staðar í að lámarki 90 daga.",
+    "LyricDownloadFailureFromForItem": "Ekki tókst að niðurhala texta frá {0} fyrir {1}",
+    "Original": "Upprunaleg"
 }
-- 
cgit v1.2.3


From 53aafcd38e1f4558ff18f5258d0d46b3a0565783 Mon Sep 17 00:00:00 2001
From: Shed Shedson <hjorturthorgeirs+hmp1devq@gmail.com>
Date: Tue, 7 Jul 2026 12:47:15 -0400
Subject: Translated using Weblate (Icelandic) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/is/

---
 Emby.Server.Implementations/Localization/Core/is.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/is.json b/Emby.Server.Implementations/Localization/Core/is.json
index 5efc241638..44e057e4de 100644
--- a/Emby.Server.Implementations/Localization/Core/is.json
+++ b/Emby.Server.Implementations/Localization/Core/is.json
@@ -105,5 +105,6 @@
     "CleanupUserDataTask": "Hreinsun notendagagna",
     "CleanupUserDataTaskDescription": "Hreinsar öll notendagögn (spilunarstöðu, uppáhöld o.s.frv.) um gögn sem hafa ekki verið til staðar í að lámarki 90 daga.",
     "LyricDownloadFailureFromForItem": "Ekki tókst að niðurhala texta frá {0} fyrir {1}",
-    "Original": "Upprunaleg"
+    "Original": "Upprunaleg",
+    "TaskExtractMediaSegmentsDescription": "Sækir myndbúta úr viðbótum þar sem MediaSegment er virkt."
 }
-- 
cgit v1.2.3


From 08f6627a24083288a1450c7af62128371b634454 Mon Sep 17 00:00:00 2001
From: Jakub Schmidtke <sjakub@gmail.com>
Date: Wed, 8 Jul 2026 01:40:26 +0200
Subject: Replaced string.Empty with ReadOnlySpan<char>.Empty

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

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/PathExtensions.cs b/Emby.Server.Implementations/Library/PathExtensions.cs
index 8815e2785a..7d0f3900c5 100644
--- a/Emby.Server.Implementations/Library/PathExtensions.cs
+++ b/Emby.Server.Implementations/Library/PathExtensions.cs
@@ -36,7 +36,7 @@ namespace Emby.Server.Implementations.Library
                 _ when attribute.Equals("tmdbid", StringComparison.OrdinalIgnoreCase) => "tmdb",
                 _ when attribute.Equals("tvdbid", StringComparison.OrdinalIgnoreCase) => "tvdb",
                 _ when attribute.Equals("imdbid", StringComparison.OrdinalIgnoreCase) => "imdb",
-                _ => string.Empty
+                _ => ReadOnlySpan<char>.Empty
             };
 
             for (int strIndex = 0, attributeIndex = 0; attributeIndex > -1;)
-- 
cgit v1.2.3


From 5e42941d3b8345ae3927c8071d4b6e5b117bd03c Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Wed, 8 Jul 2026 12:09:38 -0400
Subject: Fix Greece parental ratings

---
 .../Localization/Ratings/gr.json                   | 27 +++++++++++++++++++---
 1 file changed, 24 insertions(+), 3 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Ratings/gr.json b/Emby.Server.Implementations/Localization/Ratings/gr.json
index 794bf0b313..73abab72d3 100644
--- a/Emby.Server.Implementations/Localization/Ratings/gr.json
+++ b/Emby.Server.Implementations/Localization/Ratings/gr.json
@@ -10,21 +10,42 @@
             }
         },
         {
-            "ratingStrings": ["K12"],
+            "ratingStrings": ["K12", "K-12", "12"],
+            "ratingScore": {
+                "score": 12,
+                "subScore": null
+            }
+        },
+        {
+            "ratingStrings": ["K13", "K-13", "13"],
             "ratingScore": {
                 "score": 13,
                 "subScore": null
             }
         },
         {
-            "ratingStrings": ["K15"],
+            "ratingStrings": ["K15", "K-15", "15"],
             "ratingScore": {
                 "score": 15,
                 "subScore": null
             }
         },
         {
-            "ratingStrings": ["K18"],
+            "ratingStrings": ["K16", "K-16", "16"],
+            "ratingScore": {
+                "score": 16,
+                "subScore": null
+            }
+        },
+        {
+            "ratingStrings": ["K17", "K-17", "17"],
+            "ratingScore": {
+                "score": 17,
+                "subScore": null
+            }
+        },
+        {
+            "ratingStrings": ["K18", "K-18", "18", "18+"],
             "ratingScore": {
                 "score": 18,
                 "subScore": null
-- 
cgit v1.2.3


From 8bf1710e0771eaebfa2933d0f7849484566f2bd5 Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Wed, 8 Jul 2026 20:09:49 -0400
Subject: Check numeric rating value after splitting country code

---
 .../Localization/LocalizationManager.cs             | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/LocalizationManager.cs b/Emby.Server.Implementations/Localization/LocalizationManager.cs
index 98f629d31c..c3e77bb87f 100644
--- a/Emby.Server.Implementations/Localization/LocalizationManager.cs
+++ b/Emby.Server.Implementations/Localization/LocalizationManager.cs
@@ -385,7 +385,7 @@ namespace Emby.Server.Implementations.Localization
 
             // Convert ints directly
             // This may override some of the locale specific age ratings (but those always map to the same age)
-            if (int.TryParse(rating, out var ratingAge))
+            if (TryParseRatingAsScore(rating, out var ratingAge))
             {
                 return new(ratingAge, null);
             }
@@ -487,6 +487,13 @@ namespace Emby.Server.Implementations.Localization
                     return true;
                 }
 
+                // If it's not a recognized rating string, fall back to using the number as the score
+                if (TryParseRatingAsScore(ratingPart, out var numericScore))
+                {
+                    result = new ParentalRatingScore(numericScore, null);
+                    return true;
+                }
+
                 _logger.LogWarning(
                     "Rating '{Rating}' not found in the '{CountryCode}' rating system, treating as unrated",
                     rating,
@@ -501,6 +508,18 @@ namespace Emby.Server.Implementations.Localization
             return true;
         }
 
+        /// <summary>
+        /// Tries to parse a rating as a number, allowing an optional trailing '+' (e.g. "16" or "18+").
+        /// </summary>
+        /// <param name="ratingValue">Rating value to parse.</param>
+        /// <param name="score">Parsed score.</param>
+        /// <returns>Returns true if parsing was successful.</returns>
+        private static bool TryParseRatingAsScore(string ratingValue, out int score)
+        {
+            var trimmed = ratingValue.TrimEnd('+');
+            return int.TryParse(trimmed, out score);
+        }
+
         /// <inheritdoc />
         public string GetLocalizedString(string phrase)
         {
-- 
cgit v1.2.3


From 853922443fdd56f6467349bbf7db5d0dc29f570e Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 9 Jul 2026 11:54:18 +0200
Subject: Remove episode image override hack

---
 Emby.Server.Implementations/Dto/DtoService.cs      | 16 ------------
 .../Dto/DtoServiceTests.cs                         | 29 ++++++++++++++--------
 2 files changed, 19 insertions(+), 26 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 5c76c4014a..c3a9253f29 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -1392,31 +1392,15 @@ namespace Emby.Server.Implementations.Dto
                         ? GetTagAndFillBlurhash(dto, episodeSeason, ImageType.Primary)
                         : null;
 
-                    BaseItem? posterParent = null;
                     if (seasonPrimaryTag is not null)
                     {
                         dto.ParentPrimaryImageItemId = episodeSeason!.Id;
                         dto.ParentPrimaryImageTag = seasonPrimaryTag;
-                        posterParent = episodeSeason;
                     }
                     else if (episodeSeries is not null && dto.SeriesPrimaryImageTag is not null)
                     {
                         dto.ParentPrimaryImageItemId = episodeSeries.Id;
                         dto.ParentPrimaryImageTag = dto.SeriesPrimaryImageTag;
-                        posterParent = episodeSeries;
-                    }
-
-                    if (posterParent is not null)
-                    {
-                        if (dto.ImageTags is not null && dto.ImageTags.Remove(ImageType.Primary, out var ownPrimaryTag))
-                        {
-                            // Only drop the episode's own primary blurhash; keep the poster parent's.
-                            dto.ImageBlurHashes?.GetValueOrDefault(ImageType.Primary)?.Remove(ownPrimaryTag);
-                        }
-
-                        dto.SeriesPrimaryImageTag = null;
-                        dto.PrimaryImageAspectRatio = null;
-                        AttachPrimaryImageAspectRatio(dto, posterParent);
                     }
                 }
 
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
index a5de0a4416..4e5790012f 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
@@ -11,6 +11,7 @@ using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Trickplay;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Querying;
 using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
@@ -56,20 +57,26 @@ public class DtoServiceTests
     }
 
     [Fact]
-    public void GetBaseItemDto_PreferEpisodeParentPoster_PrefersSeasonPosterOverEpisodeAndSeries()
+    public void GetBaseItemDto_PreferEpisodeParentPoster_AttachesSeasonPosterWithoutDroppingEpisodeImage()
     {
-        var (episode, season, series) = BuildEpisode(seasonHasPoster: true);
-        var options = new DtoOptions(false) { PreferEpisodeParentPoster = true };
+        var (episode, season, _) = BuildEpisode(seasonHasPoster: true);
+        var options = new DtoOptions(false)
+        {
+            PreferEpisodeParentPoster = true,
+            Fields = [ItemFields.PrimaryImageAspectRatio]
+        };
 
         var dto = _dtoService.GetBaseItemDto(episode, options);
 
-        // The episode's own 16:9 primary is dropped in favor of the season's portrait poster.
-        Assert.False(dto.ImageTags is not null && dto.ImageTags.ContainsKey(ImageType.Primary));
-        Assert.Null(dto.SeriesPrimaryImageTag);
+        // The season poster is attached additively; the episode keeps its own primary and 16:9 ratio,
+        // and clients decide per view whether to prefer the parent/series poster over the episode still.
+        Assert.NotNull(dto.ImageTags);
+        Assert.True(dto.ImageTags.ContainsKey(ImageType.Primary));
+        Assert.NotNull(dto.SeriesPrimaryImageTag);
         Assert.Equal(season.Id, dto.ParentPrimaryImageItemId);
         Assert.Equal("tag:" + season.GetImageInfo(ImageType.Primary, 0)!.Path, dto.ParentPrimaryImageTag);
-        // Aspect ratio follows the (portrait) poster, not the episode's 16:9 image.
-        Assert.Equal(season.GetDefaultPrimaryImageAspectRatio(), dto.PrimaryImageAspectRatio);
+        // Aspect ratio stays the episode's own image, not the poster's.
+        Assert.Equal(episode.GetDefaultPrimaryImageAspectRatio(), dto.PrimaryImageAspectRatio);
     }
 
     [Fact]
@@ -80,8 +87,10 @@ public class DtoServiceTests
 
         var dto = _dtoService.GetBaseItemDto(episode, options);
 
-        Assert.False(dto.ImageTags is not null && dto.ImageTags.ContainsKey(ImageType.Primary));
-        Assert.Null(dto.SeriesPrimaryImageTag);
+        // Episode image is retained; ParentPrimaryImage falls back to the series poster.
+        Assert.NotNull(dto.ImageTags);
+        Assert.True(dto.ImageTags.ContainsKey(ImageType.Primary));
+        Assert.NotNull(dto.SeriesPrimaryImageTag);
         Assert.Equal(series.Id, dto.ParentPrimaryImageItemId);
         Assert.Equal("tag:" + series.GetImageInfo(ImageType.Primary, 0)!.Path, dto.ParentPrimaryImageTag);
     }
-- 
cgit v1.2.3


From 38813f7d4288813ad8e7582a87d14daa6a129852 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 9 Jul 2026 12:07:13 +0200
Subject: Cleanup PreferEpisodeParentPoster)

---
 Emby.Server.Implementations/Dto/DtoService.cs      |  2 +-
 Jellyfin.Api/Controllers/UserLibraryController.cs  |  2 --
 MediaBrowser.Controller/Dto/DtoOptions.cs          |  7 ------
 .../Dto/DtoServiceTests.cs                         | 26 ++++++++++------------
 4 files changed, 13 insertions(+), 24 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index c3a9253f29..8cbf42585d 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -1385,7 +1385,7 @@ namespace Emby.Server.Implementations.Dto
                     }
                 }
 
-                if (options.PreferEpisodeParentPoster)
+                if (options.GetImageLimit(ImageType.Primary) > 0)
                 {
                     var episodeSeason = episode.Season;
                     var seasonPrimaryTag = episodeSeason is not null
diff --git a/Jellyfin.Api/Controllers/UserLibraryController.cs b/Jellyfin.Api/Controllers/UserLibraryController.cs
index 25f781e496..a718035528 100644
--- a/Jellyfin.Api/Controllers/UserLibraryController.cs
+++ b/Jellyfin.Api/Controllers/UserLibraryController.cs
@@ -551,8 +551,6 @@ public class UserLibraryController : BaseJellyfinApiController
         var dtoOptions = new DtoOptions { Fields = fields }
             .AddAdditionalDtoOptions(enableImages, enableUserData, imageTypeLimit, enableImageTypes);
 
-        dtoOptions.PreferEpisodeParentPoster = true;
-
         var list = _userViewManager.GetLatestItems(
             new LatestItemsQuery
             {
diff --git a/MediaBrowser.Controller/Dto/DtoOptions.cs b/MediaBrowser.Controller/Dto/DtoOptions.cs
index d319feb6b2..052626355f 100644
--- a/MediaBrowser.Controller/Dto/DtoOptions.cs
+++ b/MediaBrowser.Controller/Dto/DtoOptions.cs
@@ -81,13 +81,6 @@ namespace MediaBrowser.Controller.Dto
         /// </summary>
         public bool AddCurrentProgram { get; set; }
 
-        /// <summary>
-        /// Gets or sets a value indicating whether an episode's portrait poster (its season's primary
-        /// image, falling back to the series') should replace the episode's own (16:9) primary image.
-        /// Used by views that render episodes as poster cards, e.g. "Latest".
-        /// </summary>
-        public bool PreferEpisodeParentPoster { get; set; }
-
         /// <summary>
         /// Gets a value indicating whether the specified field is populated.
         /// </summary>
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
index 4e5790012f..9c247d54b9 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
@@ -57,14 +57,10 @@ public class DtoServiceTests
     }
 
     [Fact]
-    public void GetBaseItemDto_PreferEpisodeParentPoster_AttachesSeasonPosterWithoutDroppingEpisodeImage()
+    public void GetBaseItemDto_Episode_AttachesSeasonPosterAsParentPrimaryImage()
     {
         var (episode, season, _) = BuildEpisode(seasonHasPoster: true);
-        var options = new DtoOptions(false)
-        {
-            PreferEpisodeParentPoster = true,
-            Fields = [ItemFields.PrimaryImageAspectRatio]
-        };
+        var options = new DtoOptions(false) { Fields = [ItemFields.PrimaryImageAspectRatio] };
 
         var dto = _dtoService.GetBaseItemDto(episode, options);
 
@@ -80,10 +76,10 @@ public class DtoServiceTests
     }
 
     [Fact]
-    public void GetBaseItemDto_PreferEpisodeParentPoster_FallsBackToSeriesWhenSeasonHasNoPoster()
+    public void GetBaseItemDto_Episode_ParentPrimaryImageFallsBackToSeriesWhenSeasonHasNoPoster()
     {
         var (episode, _, series) = BuildEpisode(seasonHasPoster: false);
-        var options = new DtoOptions(false) { PreferEpisodeParentPoster = true };
+        var options = new DtoOptions(false);
 
         var dto = _dtoService.GetBaseItemDto(episode, options);
 
@@ -96,26 +92,28 @@ public class DtoServiceTests
     }
 
     [Fact]
-    public void GetBaseItemDto_WithoutPreferEpisodeParentPoster_KeepsEpisodePrimary()
+    public void GetBaseItemDto_Episode_WithoutParentPosters_KeepsOnlyEpisodePrimary()
     {
-        var (episode, _, _) = BuildEpisode(seasonHasPoster: true);
+        var (episode, _, _) = BuildEpisode(seasonHasPoster: false, seriesHasPoster: false);
         var options = new DtoOptions(false);
 
         var dto = _dtoService.GetBaseItemDto(episode, options);
 
-        // Default behavior: the episode keeps its own primary and exposes the series poster as a tag.
+        // With no season or series poster there is nothing to attach; the episode keeps its own primary.
         Assert.NotNull(dto.ImageTags);
         Assert.True(dto.ImageTags.ContainsKey(ImageType.Primary));
-        Assert.NotNull(dto.SeriesPrimaryImageTag);
         Assert.Null(dto.ParentPrimaryImageItemId);
     }
 
-    private (Episode Episode, Season Season, Series Series) BuildEpisode(bool seasonHasPoster)
+    private (Episode Episode, Season Season, Series Series) BuildEpisode(bool seasonHasPoster, bool seriesHasPoster = true)
     {
         // Non-local (http) paths keep aspect-ratio resolution off the image processor and on the
         // item's default ratio, which is portrait (2/3) for Season/Series and 16:9 for Episode.
         var series = new Series { Id = Guid.NewGuid(), Name = "Series" };
-        series.SetImage(new ItemImageInfo { Type = ImageType.Primary, Path = "http://test/series.jpg" }, 0);
+        if (seriesHasPoster)
+        {
+            series.SetImage(new ItemImageInfo { Type = ImageType.Primary, Path = "http://test/series.jpg" }, 0);
+        }
 
         var season = new Season { Id = Guid.NewGuid(), Name = "Season", SeriesId = series.Id };
         if (seasonHasPoster)
-- 
cgit v1.2.3


From 631a314d24bd2c7e1b3e0b81aa65437586794ccd Mon Sep 17 00:00:00 2001
From: nyanmisaka <nst799610810@gmail.com>
Date: Fri, 10 Jul 2026 14:46:27 +0800
Subject: Fix potential garbled text in FFmpeg logs on Windows

Explicitly set StandardErrorEncoding and StandardOutputEncoding to
Encoding.UTF8 when invoking the FFmpeg subprocess.

This prevents log encoding issues and character corruption on Windows
environments that default to non-UTF8 ANSI code pages.

This fixes garbled metadata and font names in the FFmpeg logs.

Signed-off-by: nyanmisaka <nst799610810@gmail.com>
---
 .../ScheduledTasks/Tasks/AudioNormalizationTask.cs                     | 3 ++-
 MediaBrowser.MediaEncoding/Encoder/EncoderValidator.cs                 | 3 +++
 MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs                     | 2 ++
 MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs             | 1 +
 src/Jellyfin.LiveTv/IO/EncodedRecorder.cs                              | 1 +
 .../FfProbe/FfProbeKeyframeExtractor.cs                                | 2 ++
 6 files changed, 11 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ScheduledTasks/Tasks/AudioNormalizationTask.cs b/Emby.Server.Implementations/ScheduledTasks/Tasks/AudioNormalizationTask.cs
index b2dc89be28..e4939205c9 100644
--- a/Emby.Server.Implementations/ScheduledTasks/Tasks/AudioNormalizationTask.cs
+++ b/Emby.Server.Implementations/ScheduledTasks/Tasks/AudioNormalizationTask.cs
@@ -4,6 +4,7 @@ using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Text;
 using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
@@ -234,7 +235,7 @@ public partial class AudioNormalizationTask : IScheduledTask
             {
                 FileName = _mediaEncoder.EncoderPath,
                 Arguments = args,
-                RedirectStandardOutput = false,
+                StandardErrorEncoding = Encoding.UTF8,
                 RedirectStandardError = true
             },
         })
diff --git a/MediaBrowser.MediaEncoding/Encoder/EncoderValidator.cs b/MediaBrowser.MediaEncoding/Encoder/EncoderValidator.cs
index 68d6d215b2..c8670c67cc 100644
--- a/MediaBrowser.MediaEncoding/Encoder/EncoderValidator.cs
+++ b/MediaBrowser.MediaEncoding/Encoder/EncoderValidator.cs
@@ -6,6 +6,7 @@ using System.Diagnostics;
 using System.Globalization;
 using System.Linq;
 using System.Runtime.Versioning;
+using System.Text;
 using System.Text.RegularExpressions;
 using MediaBrowser.Controller.MediaEncoding;
 using Microsoft.Extensions.Logging;
@@ -645,7 +646,9 @@ namespace MediaBrowser.MediaEncoding.Encoder
                     WindowStyle = ProcessWindowStyle.Hidden,
                     ErrorDialog = false,
                     RedirectStandardInput = redirectStandardIn,
+                    StandardOutputEncoding = Encoding.UTF8,
                     RedirectStandardOutput = true,
+                    StandardErrorEncoding = Encoding.UTF8,
                     RedirectStandardError = true
                 }
             })
diff --git a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
index 66bf6ebd24..1199fd7d70 100644
--- a/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
+++ b/MediaBrowser.MediaEncoding/Encoder/MediaEncoder.cs
@@ -7,6 +7,7 @@ using System.Diagnostics;
 using System.Globalization;
 using System.IO;
 using System.Linq;
+using System.Text;
 using System.Text.Json;
 using System.Text.RegularExpressions;
 using System.Threading;
@@ -528,6 +529,7 @@ namespace MediaBrowser.MediaEncoding.Encoder
                     UseShellExecute = false,
 
                     // Must consume both or ffmpeg may hang due to deadlocks.
+                    StandardOutputEncoding = Encoding.UTF8,
                     RedirectStandardOutput = true,
 
                     FileName = _ffprobePath,
diff --git a/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs b/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs
index defd855ec0..78bb881ec2 100644
--- a/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs
+++ b/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs
@@ -424,6 +424,7 @@ public sealed class TranscodeManager : ITranscodeManager, IDisposable
 
                 // Must consume both stdout and stderr or deadlocks may occur
                 // RedirectStandardOutput = true,
+                StandardErrorEncoding = Encoding.UTF8,
                 RedirectStandardError = true,
                 RedirectStandardInput = true,
                 FileName = _mediaEncoder.EncoderPath,
diff --git a/src/Jellyfin.LiveTv/IO/EncodedRecorder.cs b/src/Jellyfin.LiveTv/IO/EncodedRecorder.cs
index d877a0d124..19c4514766 100644
--- a/src/Jellyfin.LiveTv/IO/EncodedRecorder.cs
+++ b/src/Jellyfin.LiveTv/IO/EncodedRecorder.cs
@@ -83,6 +83,7 @@ namespace Jellyfin.LiveTv.IO
                 CreateNoWindow = true,
                 UseShellExecute = false,
 
+                StandardErrorEncoding = Encoding.UTF8,
                 RedirectStandardError = true,
                 RedirectStandardInput = true,
 
diff --git a/src/Jellyfin.MediaEncoding.Keyframes/FfProbe/FfProbeKeyframeExtractor.cs b/src/Jellyfin.MediaEncoding.Keyframes/FfProbe/FfProbeKeyframeExtractor.cs
index cbe97a8210..af868e4bd6 100644
--- a/src/Jellyfin.MediaEncoding.Keyframes/FfProbe/FfProbeKeyframeExtractor.cs
+++ b/src/Jellyfin.MediaEncoding.Keyframes/FfProbe/FfProbeKeyframeExtractor.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Diagnostics;
 using System.Globalization;
 using System.IO;
+using System.Text;
 
 namespace Jellyfin.MediaEncoding.Keyframes.FfProbe;
 
@@ -31,6 +32,7 @@ public static class FfProbeKeyframeExtractor
 
                 CreateNoWindow = true,
                 UseShellExecute = false,
+                StandardOutputEncoding = Encoding.UTF8,
                 RedirectStandardOutput = true,
 
                 WindowStyle = ProcessWindowStyle.Hidden,
-- 
cgit v1.2.3


From 2aae53bc152682ddf845d6ba17e4cb109d39bca8 Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Sun, 12 Jul 2026 11:54:56 -0400
Subject: Apply review feedback

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

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/LocalizationManager.cs b/Emby.Server.Implementations/Localization/LocalizationManager.cs
index c3e77bb87f..e7dd984ec4 100644
--- a/Emby.Server.Implementations/Localization/LocalizationManager.cs
+++ b/Emby.Server.Implementations/Localization/LocalizationManager.cs
@@ -514,7 +514,7 @@ namespace Emby.Server.Implementations.Localization
         /// <param name="ratingValue">Rating value to parse.</param>
         /// <param name="score">Parsed score.</param>
         /// <returns>Returns true if parsing was successful.</returns>
-        private static bool TryParseRatingAsScore(string ratingValue, out int score)
+        private static bool TryParseRatingAsScore(ReadOnlySpan<char> ratingValue, out int score)
         {
             var trimmed = ratingValue.TrimEnd('+');
             return int.TryParse(trimmed, out score);
-- 
cgit v1.2.3


From 0584a102ee3ac17b08bf660bdd1a10ef7978f77a Mon Sep 17 00:00:00 2001
From: DrummingBird1 <idan062@gmail.com>
Date: Sun, 12 Jul 2026 07:10:52 -0400
Subject: Translated using Weblate (Hebrew) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/he/

---
 Emby.Server.Implementations/Localization/Core/he.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/he.json b/Emby.Server.Implementations/Localization/Core/he.json
index af34bf092e..48056b0bb8 100644
--- a/Emby.Server.Implementations/Localization/Core/he.json
+++ b/Emby.Server.Implementations/Localization/Core/he.json
@@ -106,5 +106,7 @@
     "TaskExtractMediaSegmentsDescription": "מחלץ חלקי מדיה מתוספים המאפשרים זאת.",
     "TaskMoveTrickplayImagesDescription": "הזזת קבצי Trickplay קיימים בהתאם להגדרות הספרייה.",
     "CleanupUserDataTaskDescription": "ניקוי כל המידע של המשתמש (מצב צפייה, מועדפים וכו) ממדיה שאינה קיימת מעל 90 יום.",
-    "CleanupUserDataTask": "משימת ניקוי מידע משתמש"
+    "CleanupUserDataTask": "משימת ניקוי מידע משתמש",
+    "LyricDownloadFailureFromForItem": "הורדת המילים מ-{0} עבור {1} נכשלה",
+    "Original": "מקור"
 }
-- 
cgit v1.2.3


From fcce10894816768f275173eb6905c5aea402e515 Mon Sep 17 00:00:00 2001
From: Jordan Rushing <jordanmichaelrushing@users.noreply.github.com>
Date: Mon, 13 Jul 2026 15:40:40 -0500
Subject: Fix: Fetch the correct row matching the most up to date file

---
 .../Library/UserDataManager.cs                     |  33 ++++-
 .../Library/UserDataManagerTests.cs                | 149 +++++++++++++++++++++
 2 files changed, 180 insertions(+), 2 deletions(-)
 create mode 100644 tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index 40cd2bb69c..58126b97b2 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -192,7 +192,8 @@ namespace Emby.Server.Implementations.Library
                 }
                 else
                 {
-                    var userData = item.UserData?.Where(e => e.UserId.Equals(user.Id)).Select(Map).FirstOrDefault();
+                    var userDataRow = ResolveUserDataRow(item, item.UserData?.Where(e => e.UserId.Equals(user.Id)));
+                    var userData = userDataRow is not null ? Map(userDataRow) : null;
                     if (userData is not null)
                     {
                         result[item.Id] = userData;
@@ -356,12 +357,40 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public UserItemData? GetUserData(User user, BaseItem item)
         {
-            return item.UserData?.Where(e => e.UserId.Equals(user.Id)).Select(Map).FirstOrDefault() ?? new UserItemData()
+            var row = ResolveUserDataRow(item, item.UserData?.Where(e => e.UserId.Equals(user.Id)));
+            return row is not null ? Map(row) : new UserItemData()
             {
                 Key = item.GetUserDataKeys()[0],
             };
         }
 
+        /// <summary>
+        /// Picks the row matching the item's current user data keys, in key order, so rows left behind
+        /// under keys from older metadata don't take priority over the rows the write path updates.
+        /// </summary>
+        /// <param name="item">The item whose keys to match.</param>
+        /// <param name="rows">The candidate user data rows for a single user.</param>
+        /// <returns>The best matching row, or <c>null</c> when there are none.</returns>
+        private static UserData? ResolveUserDataRow(BaseItem item, IEnumerable<UserData>? rows)
+        {
+            var candidates = rows?.ToList();
+            if (candidates is null || candidates.Count == 0)
+            {
+                return null;
+            }
+
+            foreach (var key in item.GetUserDataKeys())
+            {
+                var match = candidates.Find(e => string.Equals(e.CustomDataKey, key, StringComparison.Ordinal));
+                if (match is not null)
+                {
+                    return match;
+                }
+            }
+
+            return candidates[0];
+        }
+
         /// <inheritdoc />
         public UserItemDataDto? GetUserDataDto(BaseItem item, User user)
             => GetUserDataDto(item, null, user, new DtoOptions());
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs
new file mode 100644
index 0000000000..092e87b9ff
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs
@@ -0,0 +1,149 @@
+using System;
+using System.Collections.Generic;
+using Emby.Server.Implementations.Library;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Model.Configuration;
+using Microsoft.EntityFrameworkCore;
+using Moq;
+using Xunit;
+using AudioBook = MediaBrowser.Controller.Entities.AudioBook;
+
+namespace Jellyfin.Server.Implementations.Tests.Library;
+
+public class UserDataManagerTests
+{
+    private readonly UserDataManager _userDataManager;
+    private readonly User _user;
+
+    public UserDataManagerTests()
+    {
+        var config = new Mock<IServerConfigurationManager>();
+        config.SetupGet(c => c.Configuration).Returns(new ServerConfiguration());
+
+        var repository = Mock.Of<IDbContextFactory<JellyfinDbContext>>();
+
+        _userDataManager = new UserDataManager(config.Object, repository);
+        _user = new User("user", "auth-provider", "reset-provider")
+        {
+            Id = Guid.NewGuid()
+        };
+    }
+
+    private AudioBook CreateAudioBook()
+    {
+        // GetUserDataKeys(): ["Author-Series-0001Book Title", "<item id N>"]
+        return new AudioBook
+        {
+            Id = Guid.NewGuid(),
+            Name = "Book Title",
+            Album = "Series",
+            AlbumArtists = new[] { "Author" },
+            IndexNumber = 1
+        };
+    }
+
+    private UserData CreateUserDataRow(AudioBook item, string key, long positionTicks)
+    {
+        return new UserData
+        {
+            ItemId = item.Id,
+            Item = null,
+            UserId = _user.Id,
+            User = null,
+            CustomDataKey = key,
+            PlaybackPositionTicks = positionTicks
+        };
+    }
+
+    [Fact]
+    public void GetUserData_RowsUnderCurrentAndRetiredKeys_PrefersCurrentKeyRow()
+    {
+        var item = CreateAudioBook();
+        var currentKey = item.GetUserDataKeys()[0];
+
+        // the retired-key row comes first to ensure selection is by key, not row order
+        item.UserData = new List<UserData>
+        {
+            CreateUserDataRow(item, "Author-Old Album-0001Old File Name", 111),
+            CreateUserDataRow(item, currentKey, 222)
+        };
+
+        var userData = _userDataManager.GetUserData(_user, item);
+
+        Assert.NotNull(userData);
+        Assert.Equal(currentKey, userData.Key);
+        Assert.Equal(222, userData.PlaybackPositionTicks);
+    }
+
+    [Fact]
+    public void GetUserData_NoPrimaryKeyRow_UsesNextCurrentKeyRow()
+    {
+        var item = CreateAudioBook();
+        var idKey = item.GetUserDataKeys()[1];
+
+        item.UserData = new List<UserData>
+        {
+            CreateUserDataRow(item, "Author-Old Album-0001Old File Name", 111),
+            CreateUserDataRow(item, idKey, 333)
+        };
+
+        var userData = _userDataManager.GetUserData(_user, item);
+
+        Assert.NotNull(userData);
+        Assert.Equal(idKey, userData.Key);
+        Assert.Equal(333, userData.PlaybackPositionTicks);
+    }
+
+    [Fact]
+    public void GetUserData_OnlyRetiredKeyRows_ReturnsRetiredKeyRow()
+    {
+        var item = CreateAudioBook();
+
+        item.UserData = new List<UserData>
+        {
+            CreateUserDataRow(item, "Author-Old Album-0001Old File Name", 111)
+        };
+
+        var userData = _userDataManager.GetUserData(_user, item);
+
+        Assert.NotNull(userData);
+        Assert.Equal(111, userData.PlaybackPositionTicks);
+    }
+
+    [Fact]
+    public void GetUserData_NoRows_ReturnsDefaultWithPrimaryKey()
+    {
+        var item = CreateAudioBook();
+        item.UserData = new List<UserData>();
+
+        var userData = _userDataManager.GetUserData(_user, item);
+
+        Assert.NotNull(userData);
+        Assert.Equal(item.GetUserDataKeys()[0], userData.Key);
+        Assert.Equal(0, userData.PlaybackPositionTicks);
+    }
+
+    [Fact]
+    public void GetUserData_RowsForOtherUsers_AreIgnored()
+    {
+        var item = CreateAudioBook();
+        var currentKey = item.GetUserDataKeys()[0];
+
+        var otherUserRow = CreateUserDataRow(item, currentKey, 999);
+        otherUserRow.UserId = Guid.NewGuid();
+
+        item.UserData = new List<UserData>
+        {
+            otherUserRow,
+            CreateUserDataRow(item, currentKey, 222)
+        };
+
+        var userData = _userDataManager.GetUserData(_user, item);
+
+        Assert.NotNull(userData);
+        Assert.Equal(222, userData.PlaybackPositionTicks);
+    }
+}
-- 
cgit v1.2.3


From b8bac71270f7b2fccbbdda1f28e1f50a554c7383 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Tue, 14 Jul 2026 10:05:32 +0200
Subject: remove PlaybackPositionTicks from MediaSourceInfo

---
 .../Library/MediaSourceManager.cs                      | 18 ++++--------------
 MediaBrowser.Model/Dto/MediaSourceInfo.cs              |  5 -----
 .../Library/MediaSourceManagerTests.cs                 | 12 +++---------
 3 files changed, 7 insertions(+), 28 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/MediaSourceManager.cs b/Emby.Server.Implementations/Library/MediaSourceManager.cs
index c64833ddaa..97e00177b6 100644
--- a/Emby.Server.Implementations/Library/MediaSourceManager.cs
+++ b/Emby.Server.Implementations/Library/MediaSourceManager.cs
@@ -418,10 +418,10 @@ namespace Emby.Server.Implementations.Library
         }
 
         /// <summary>
-        /// Populates each source's own playback position for the user and, when the queried item is a
-        /// primary, moves the most recently played version to the front so that resuming without an
-        /// explicit source selection plays the version that was last watched. A directly queried
-        /// alternate version keeps its own source first.
+        /// When the queried item is a primary, moves the most recently played version to the front so
+        /// that resuming without an explicit source selection plays the version that was last watched.
+        /// A directly queried alternate version keeps its own source first. Per-user playback position
+        /// is not surfaced on the source itself; it is carried by each version's own UserData.
         /// </summary>
         /// <param name="item">The queried item.</param>
         /// <param name="sources">The item's media sources.</param>
@@ -451,16 +451,6 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            foreach (var source in sources)
-            {
-                if (source.Id is not null
-                    && dataBySourceId.TryGetValue(source.Id, out var data)
-                    && data.PlaybackPositionTicks > 0)
-                {
-                    source.PlaybackPositionTicks = data.PlaybackPositionTicks;
-                }
-            }
-
             // Reorder only for a resumable (in-progress) version;
             // a completed version has no position to resume, so it must not be pulled to the front here.
             var resumeSource = VersionPlaybackSelector.SelectMostRecentlyPlayed(
diff --git a/MediaBrowser.Model/Dto/MediaSourceInfo.cs b/MediaBrowser.Model/Dto/MediaSourceInfo.cs
index 017e26ef59..75ccdcf276 100644
--- a/MediaBrowser.Model/Dto/MediaSourceInfo.cs
+++ b/MediaBrowser.Model/Dto/MediaSourceInfo.cs
@@ -55,11 +55,6 @@ namespace MediaBrowser.Model.Dto
 
         public long? RunTimeTicks { get; set; }
 
-        /// <summary>
-        /// Gets or sets the playback position for this specific source.
-        /// </summary>
-        public long? PlaybackPositionTicks { get; set; }
-
         public bool ReadAtNativeFramerate { get; set; }
 
         public bool IgnoreDts { get; set; }
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
index b788fb304e..c80f899498 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/MediaSourceManagerTests.cs
@@ -150,7 +150,7 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         }
 
         [Fact]
-        public void GetStaticMediaSources_PrimaryQueried_PopulatesPerVersionPositionsAndDefaultsToMostRecent()
+        public void GetStaticMediaSources_PrimaryQueried_DefaultsToMostRecentlyPlayedVersion()
         {
             var (primary, alt1, alt2) = SetupVersionGroup();
             SetupUserDataBatch(new Dictionary<Guid, UserItemData>
@@ -161,12 +161,8 @@ namespace Jellyfin.Server.Implementations.Tests.Library
 
             var sources = _mediaSourceManager.GetStaticMediaSources(primary, false, _user);
 
-            // Each version carries its own resume point; the primary has none.
-            Assert.Equal((long?)10, sources.First(s => s.Id == alt1.Id.ToString("N")).PlaybackPositionTicks);
-            Assert.Equal((long?)20, sources.First(s => s.Id == alt2.Id.ToString("N")).PlaybackPositionTicks);
-            Assert.Null(sources.First(s => s.Id == primary.Id.ToString("N")).PlaybackPositionTicks);
-
             // The most recently played version is the default source, so resuming plays the right file.
+            // Per-user positions live in each version's UserData, not on the source.
             Assert.Equal(alt2.Id.ToString("N"), sources[0].Id);
         }
 
@@ -182,9 +178,8 @@ namespace Jellyfin.Server.Implementations.Tests.Library
             var sources = _mediaSourceManager.GetStaticMediaSources(alt1, false, _user);
 
             // An explicitly opened version keeps its own source first, even when a sibling was
-            // played more recently, but the sibling's resume point is still populated.
+            // played more recently.
             Assert.Equal(alt1.Id.ToString("N"), sources[0].Id);
-            Assert.Equal((long?)20, sources.First(s => s.Id == alt2.Id.ToString("N")).PlaybackPositionTicks);
             Assert.Equal(3, sources.Count);
         }
 
@@ -197,7 +192,6 @@ namespace Jellyfin.Server.Implementations.Tests.Library
             var sources = _mediaSourceManager.GetStaticMediaSources(primary, false, _user);
 
             Assert.Equal(primary.Id.ToString("N"), sources[0].Id);
-            Assert.All(sources, s => Assert.Null(s.PlaybackPositionTicks));
         }
 
         [Fact]
-- 
cgit v1.2.3


From c6545a8b688380bc6ae6f27a449d5a7f2dd1253a Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Wed, 15 Jul 2026 11:47:59 +0200
Subject: Limit similar items to user accessible libraries

---
 .../Library/SimilarItems/MovieSimilarItemsProvider.cs         | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/SimilarItems/MovieSimilarItemsProvider.cs b/Emby.Server.Implementations/Library/SimilarItems/MovieSimilarItemsProvider.cs
index b4ed12a20c..57d1f7c770 100644
--- a/Emby.Server.Implementations/Library/SimilarItems/MovieSimilarItemsProvider.cs
+++ b/Emby.Server.Implementations/Library/SimilarItems/MovieSimilarItemsProvider.cs
@@ -53,6 +53,7 @@ public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie
     private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
     private readonly IItemQueryHelpers _queryHelpers;
     private readonly IServerConfigurationManager _serverConfigurationManager;
+    private readonly ILibraryManager _libraryManager;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="MovieSimilarItemsProvider"/> class.
@@ -60,14 +61,17 @@ public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie
     /// <param name="dbProvider">The database context factory.</param>
     /// <param name="queryHelpers">The shared query helpers.</param>
     /// <param name="serverConfigurationManager">The server configuration manager.</param>
+    /// <param name="libraryManager">The library manager.</param>
     public MovieSimilarItemsProvider(
         IDbContextFactory<JellyfinDbContext> dbProvider,
         IItemQueryHelpers queryHelpers,
-        IServerConfigurationManager serverConfigurationManager)
+        IServerConfigurationManager serverConfigurationManager,
+        ILibraryManager libraryManager)
     {
         _dbProvider = dbProvider;
         _queryHelpers = queryHelpers;
         _serverConfigurationManager = serverConfigurationManager;
+        _libraryManager = libraryManager;
     }
 
     /// <inheritdoc/>
@@ -156,6 +160,11 @@ public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie
                 IsPlayed = false
             };
 
+            if (query.User is not null)
+            {
+                _libraryManager.ConfigureUserAccess(filter, query.User);
+            }
+
             _queryHelpers.PrepareFilterQuery(filter);
             var baseQuery = _queryHelpers.PrepareItemQuery(context, filter);
             baseQuery = _queryHelpers.TranslateQuery(baseQuery, context, filter);
-- 
cgit v1.2.3


From f8aad322ccabcc377b522e3abb375dd67476f375 Mon Sep 17 00:00:00 2001
From: mbastian77 <michael.bastian@visop.de>
Date: Wed, 15 Jul 2026 11:58:29 +0200
Subject: Add XML docs to DeviceId and remove CS1591 suppression

---
 Emby.Server.Implementations/Devices/DeviceId.cs | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Devices/DeviceId.cs b/Emby.Server.Implementations/Devices/DeviceId.cs
index 0b3c3bbd4f..4929568935 100644
--- a/Emby.Server.Implementations/Devices/DeviceId.cs
+++ b/Emby.Server.Implementations/Devices/DeviceId.cs
@@ -1,5 +1,3 @@
-#pragma warning disable CS1591
-
 using System;
 using System.Globalization;
 using System.IO;
@@ -10,6 +8,9 @@ using Microsoft.Extensions.Logging;
 
 namespace Emby.Server.Implementations.Devices
 {
+    /// <summary>
+    /// Provides the persistent unique identifier of this server installation.
+    /// </summary>
     public class DeviceId
     {
         private readonly IApplicationPaths _appPaths;
@@ -18,12 +19,20 @@ namespace Emby.Server.Implementations.Devices
 
         private string? _id;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeviceId"/> class.
+        /// </summary>
+        /// <param name="appPaths">Instance of the <see cref="IApplicationPaths"/> interface.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger{DeviceId}"/> interface.</param>
         public DeviceId(IApplicationPaths appPaths, ILogger<DeviceId> logger)
         {
             _appPaths = appPaths;
             _logger = logger;
         }
 
+        /// <summary>
+        /// Gets the device id, loading it from disk or generating and persisting a new one if none exists.
+        /// </summary>
         public string Value => _id ??= GetDeviceId();
 
         private string CachePath => Path.Combine(_appPaths.DataPath, "device.txt");
-- 
cgit v1.2.3


From 3f96790904aa80cf070929f584c8d234e227236e Mon Sep 17 00:00:00 2001
From: Jordan Rushing <jordanmichaelrushing@users.noreply.github.com>
Date: Wed, 15 Jul 2026 16:21:42 -0500
Subject: Move GetUserDataBatch to use ResolveUserDataRow when item.UserData
 isn't preloaded

---
 .../Library/UserDataManager.cs                     | 51 ++++++++--------
 .../Library/UserDataManagerTests.cs                | 68 ++++++++++++++++++++--
 2 files changed, 87 insertions(+), 32 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index 58126b97b2..00f155e132 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -212,37 +212,32 @@ namespace Emby.Server.Implementations.Library
                 return result;
             }
 
-            // Build a single query for all missing items
+            // Build a single query for all missing items. Fetch rows by item alone so rows kept
+            // under keys from older metadata resolve the same way as the in-memory path.
             var allItemIds = itemsNeedingQuery.Select(x => x.Item.Id).ToList();
-            var allKeys = itemsNeedingQuery.SelectMany(x => x.Keys).Distinct().ToList();
-            if (allKeys.Count > 0)
-            {
-                using var context = _repository.CreateDbContext();
-                var userDataArray = context.UserData
-                    .AsNoTracking()
-                    .Where(e => e.UserId.Equals(user.Id))
-                    .WhereOneOrMany(allItemIds, e => e.ItemId)
-                    .WhereOneOrMany(allKeys, e => e.CustomDataKey)
-                    .ToArray();
-
-                var userDataByItem = userDataArray.GroupBy(e => e.ItemId).ToDictionary(g => g.Key, g => g.ToArray());
-                foreach (var (item, keys) in itemsNeedingQuery)
+            using var context = _repository.CreateDbContext();
+            var userDataArray = context.UserData
+                .AsNoTracking()
+                .Where(e => e.UserId.Equals(user.Id))
+                .WhereOneOrMany(allItemIds, e => e.ItemId)
+                .ToArray();
+
+            var userDataByItem = userDataArray.GroupBy(e => e.ItemId).ToDictionary(g => g.Key, g => g.ToArray());
+            foreach (var (item, keys) in itemsNeedingQuery)
+            {
+                UserItemData userData;
+                if (userDataByItem.TryGetValue(item.Id, out var itemUserData) && itemUserData.Length > 0)
                 {
-                    UserItemData userData;
-                    if (userDataByItem.TryGetValue(item.Id, out var itemUserData) && itemUserData.Length > 0)
-                    {
-                        var directDataReference = itemUserData.FirstOrDefault(e => e.CustomDataKey == item.Id.ToString("N"));
-                        userData = directDataReference is not null ? Map(directDataReference) : Map(itemUserData.First());
-                    }
-                    else
-                    {
-                        userData = new UserItemData { Key = keys.Count > 0 ? keys[0] : string.Empty };
-                    }
-
-                    result[item.Id] = userData;
-                    var cacheKey = GetCacheKey(user.InternalId, item.Id);
-                    _cache.AddOrUpdate(cacheKey, userData);
+                    userData = Map(ResolveUserDataRow(item, itemUserData)!);
                 }
+                else
+                {
+                    userData = new UserItemData { Key = keys.Count > 0 ? keys[0] : string.Empty };
+                }
+
+                result[item.Id] = userData;
+                var cacheKey = GetCacheKey(user.InternalId, item.Id);
+                _cache.AddOrUpdate(cacheKey, userData);
             }
 
             return result;
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs
index 092e87b9ff..bd14ca008d 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs
@@ -3,35 +3,68 @@ using System.Collections.Generic;
 using Emby.Server.Implementations.Library;
 using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Locking;
+using Jellyfin.Database.Providers.Sqlite;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Model.Configuration;
+using Microsoft.Data.Sqlite;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
 using AudioBook = MediaBrowser.Controller.Entities.AudioBook;
 
 namespace Jellyfin.Server.Implementations.Tests.Library;
 
-public class UserDataManagerTests
+public sealed class UserDataManagerTests : IDisposable
 {
+    private readonly SqliteConnection _connection;
+    private readonly DbContextOptions<JellyfinDbContext> _dbOptions;
     private readonly UserDataManager _userDataManager;
     private readonly User _user;
 
     public UserDataManagerTests()
     {
+        _connection = new SqliteConnection("Data Source=:memory:");
+        _connection.Open();
+
+        _dbOptions = new DbContextOptionsBuilder<JellyfinDbContext>()
+            .UseSqlite(_connection)
+            .Options;
+
+        using (var ctx = CreateDbContext())
+        {
+            ctx.Database.EnsureCreated();
+        }
+
+        var factory = new Mock<IDbContextFactory<JellyfinDbContext>>();
+        factory.Setup(f => f.CreateDbContext()).Returns(CreateDbContext);
+
         var config = new Mock<IServerConfigurationManager>();
         config.SetupGet(c => c.Configuration).Returns(new ServerConfiguration());
 
-        var repository = Mock.Of<IDbContextFactory<JellyfinDbContext>>();
-
-        _userDataManager = new UserDataManager(config.Object, repository);
+        _userDataManager = new UserDataManager(config.Object, factory.Object);
         _user = new User("user", "auth-provider", "reset-provider")
         {
             Id = Guid.NewGuid()
         };
     }
 
+    public void Dispose()
+    {
+        _connection.Dispose();
+    }
+
+    private JellyfinDbContext CreateDbContext()
+    {
+        return new JellyfinDbContext(
+            _dbOptions,
+            NullLogger<JellyfinDbContext>.Instance,
+            new SqliteDatabaseProvider(null!, NullLogger<SqliteDatabaseProvider>.Instance),
+            new NoLockBehavior(NullLogger<NoLockBehavior>.Instance));
+    }
+
     private AudioBook CreateAudioBook()
     {
         // GetUserDataKeys(): ["Author-Series-0001Book Title", "<item id N>"]
@@ -146,4 +179,31 @@ public class UserDataManagerTests
         Assert.NotNull(userData);
         Assert.Equal(222, userData.PlaybackPositionTicks);
     }
+
+    [Fact]
+    public void GetUserDataBatch_DatabaseFallback_ResolvesRowsByKeyOrder()
+    {
+        // no preloaded navigation data, so the batch takes the database fallback
+        var fossilItem = CreateAudioBook();
+        var retiredItem = CreateAudioBook();
+
+        using (var ctx = CreateDbContext())
+        {
+            ctx.Users.Add(_user);
+            ctx.BaseItems.Add(new BaseItemEntity { Id = fossilItem.Id, Type = typeof(AudioBook).FullName! });
+            ctx.BaseItems.Add(new BaseItemEntity { Id = retiredItem.Id, Type = typeof(AudioBook).FullName! });
+
+            // the stale id-key row is inserted first so selection by row order would return it
+            ctx.UserData.AddRange(
+                CreateUserDataRow(fossilItem, fossilItem.GetUserDataKeys()[1], 111),
+                CreateUserDataRow(fossilItem, fossilItem.GetUserDataKeys()[0], 222),
+                CreateUserDataRow(retiredItem, "Author-Old Album-0001Old File Name", 333));
+            ctx.SaveChanges();
+        }
+
+        var result = _userDataManager.GetUserDataBatch([fossilItem, retiredItem], _user);
+
+        Assert.Equal(222, result[fossilItem.Id].PlaybackPositionTicks);
+        Assert.Equal(333, result[retiredItem.Id].PlaybackPositionTicks);
+    }
 }
-- 
cgit v1.2.3


From cdf7ce0fc4504eda29a2b4060fbe1fe628e2ee0a Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 16 Jul 2026 14:21:03 +0200
Subject: Fix user data batch query perf

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

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index 40cd2bb69c..19b42a3a11 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -291,8 +291,8 @@ namespace Emby.Server.Implementations.Library
             {
                 using var dbContext = _repository.CreateDbContext();
                 withLocalAlternates = dbContext.LinkedChildren
-                    .Where(lc => lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.LocalAlternateVersion
-                        && localProbeIds.Contains(lc.ParentId))
+                    .Where(lc => lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.LocalAlternateVersion)
+                    .WhereOneOrMany(localProbeIds, lc => lc.ParentId)
                     .Select(lc => lc.ParentId)
                     .Distinct()
                     .ToHashSet();
-- 
cgit v1.2.3


From 8759ad4d4986c6b5ebea1030ceca5f472065b741 Mon Sep 17 00:00:00 2001
From: Fabián Sanhueza <sanhuesoft@gmail.com>
Date: Thu, 16 Jul 2026 18:16:32 -0400
Subject: Translated using Weblate (Spanish (Latin America)) Translation:
 Jellyfin/Jellyfin Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/es_419/

---
 Emby.Server.Implementations/Localization/Core/es_419.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/es_419.json b/Emby.Server.Implementations/Localization/Core/es_419.json
index 1f13451060..4404354a88 100644
--- a/Emby.Server.Implementations/Localization/Core/es_419.json
+++ b/Emby.Server.Implementations/Localization/Core/es_419.json
@@ -106,5 +106,7 @@
     "TaskExtractMediaSegments": "Escaneo de segmentos de medios",
     "TaskMoveTrickplayImages": "Migrar la ubicación de la imagen de Trickplay",
     "CleanupUserDataTask": "Tarea de limpieza de datos de usuario",
-    "CleanupUserDataTaskDescription": "Limpia todos los datos de usuario (estado de visualización, favoritos, etc.) que no están presentes en la biblioteca por al menos 90 días."
+    "CleanupUserDataTaskDescription": "Limpia todos los datos de usuario (estado de visualización, favoritos, etc.) que no están presentes en la biblioteca por al menos 90 días.",
+    "LyricDownloadFailureFromForItem": "No se pudo descargar las letras de {0} para {1}",
+    "Original": "Original"
 }
-- 
cgit v1.2.3


From 1a45fc82b5c0b7c7623be4117d15140cda020387 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 17 Jul 2026 16:46:13 +0200
Subject: Sanitize media attachment and lyric paths against traversal

---
 Emby.Server.Implementations/Library/PathManager.cs | 15 +++++-
 .../Attachments/AttachmentExtractor.cs             |  7 ++-
 MediaBrowser.Providers/Lyric/LyricManager.cs       |  4 +-
 tests/Jellyfin.Extensions.Tests/PathHelperTests.cs | 60 ++++++++++++++++++++++
 4 files changed, 81 insertions(+), 5 deletions(-)
 create mode 100644 tests/Jellyfin.Extensions.Tests/PathHelperTests.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/PathManager.cs b/Emby.Server.Implementations/Library/PathManager.cs
index fad948ad97..2a50fcc7fe 100644
--- a/Emby.Server.Implementations/Library/PathManager.cs
+++ b/Emby.Server.Implementations/Library/PathManager.cs
@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
+using Jellyfin.Extensions;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
@@ -43,7 +44,19 @@ public class PathManager : IPathManager
     public string? GetAttachmentPath(string mediaSourceId, string fileName)
     {
         var folder = GetAttachmentFolderPath(mediaSourceId);
-        return folder is null ? null : Path.Combine(folder, fileName);
+        if (folder is null)
+        {
+            return null;
+        }
+
+        var safeName = PathHelper.GetSafeLeafFileName(fileName);
+        if (safeName is null)
+        {
+            _logger.LogWarning("Rejecting attachment filename '{FileName}' for MediaSource {MediaSourceId}: not a valid leaf name.", fileName, mediaSourceId);
+            return null;
+        }
+
+        return Path.Combine(folder, safeName);
     }
 
     /// <inheritdoc />
diff --git a/MediaBrowser.MediaEncoding/Attachments/AttachmentExtractor.cs b/MediaBrowser.MediaEncoding/Attachments/AttachmentExtractor.cs
index 9dd3dcecba..aff4af9581 100644
--- a/MediaBrowser.MediaEncoding/Attachments/AttachmentExtractor.cs
+++ b/MediaBrowser.MediaEncoding/Attachments/AttachmentExtractor.cs
@@ -8,6 +8,7 @@ using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using AsyncKeyedLock;
+using Jellyfin.Extensions;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
@@ -101,7 +102,7 @@ namespace MediaBrowser.MediaEncoding.Attachments
             CancellationToken cancellationToken)
         {
             var shouldExtractOneByOne = mediaSource.MediaAttachments.Any(a => !string.IsNullOrEmpty(a.FileName)
-                                                                              && (a.FileName.Contains('/', StringComparison.OrdinalIgnoreCase) || a.FileName.Contains('\\', StringComparison.OrdinalIgnoreCase)));
+                                                                              && PathHelper.GetSafeLeafFileName(a.FileName) != a.FileName);
             if (shouldExtractOneByOne && !inputFile.EndsWith(".mks", StringComparison.OrdinalIgnoreCase))
             {
                 await ExtractAllAttachmentsIndividuallyInternal(
@@ -387,7 +388,9 @@ namespace MediaBrowser.MediaEncoding.Attachments
 
             using (await _semaphoreLocks.LockAsync(attachmentFolderPath, cancellationToken).ConfigureAwait(false))
             {
-                var attachmentPath = _pathManager.GetAttachmentPath(mediaSource.Id, mediaAttachment.FileName ?? mediaAttachment.Index.ToString(CultureInfo.InvariantCulture))!;
+                var indexName = mediaAttachment.Index.ToString(CultureInfo.InvariantCulture);
+                var attachmentPath = _pathManager.GetAttachmentPath(mediaSource.Id, mediaAttachment.FileName ?? indexName)
+                                     ?? _pathManager.GetAttachmentPath(mediaSource.Id, indexName)!;
                 if (!File.Exists(attachmentPath))
                 {
                     await ExtractAttachmentInternal(
diff --git a/MediaBrowser.Providers/Lyric/LyricManager.cs b/MediaBrowser.Providers/Lyric/LyricManager.cs
index 913a104a0d..af31e373ef 100644
--- a/MediaBrowser.Providers/Lyric/LyricManager.cs
+++ b/MediaBrowser.Providers/Lyric/LyricManager.cs
@@ -398,7 +398,7 @@ public class LyricManager : ILyricManager
             {
                 var mediaFolderPath = Path.GetFullPath(Path.Combine(audio.ContainingFolderPath, saveFileName));
                 // TODO: Add some error handling to the API user: return BadRequest("Could not save lyric, bad path.");
-                if (mediaFolderPath.StartsWith(audio.ContainingFolderPath, StringComparison.Ordinal))
+                if (PathHelper.IsContainedIn(audio.ContainingFolderPath, mediaFolderPath))
                 {
                     savePaths.Add(mediaFolderPath);
                 }
@@ -407,7 +407,7 @@ public class LyricManager : ILyricManager
             var internalPath = Path.GetFullPath(Path.Combine(audio.GetInternalMetadataPath(), saveFileName));
 
             // TODO: Add some error to the user: return BadRequest("Could not save lyric, bad path.");
-            if (internalPath.StartsWith(audio.GetInternalMetadataPath(), StringComparison.Ordinal))
+            if (PathHelper.IsContainedIn(audio.GetInternalMetadataPath(), internalPath))
             {
                 savePaths.Add(internalPath);
             }
diff --git a/tests/Jellyfin.Extensions.Tests/PathHelperTests.cs b/tests/Jellyfin.Extensions.Tests/PathHelperTests.cs
new file mode 100644
index 0000000000..71fd853ba2
--- /dev/null
+++ b/tests/Jellyfin.Extensions.Tests/PathHelperTests.cs
@@ -0,0 +1,60 @@
+using System.IO;
+using Jellyfin.Extensions;
+using Xunit;
+
+namespace Jellyfin.Extensions.Tests
+{
+    public static class PathHelperTests
+    {
+        [Theory]
+        [InlineData("file.txt", "file.txt")]
+        [InlineData("sub/file.txt", "file.txt")]
+        [InlineData("../../etc/passwd", "passwd")]
+        public static void GetSafeLeafFileName_ReducesToLeaf(string input, string expected)
+        {
+            Assert.Equal(expected, PathHelper.GetSafeLeafFileName(input));
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData(".")]
+        [InlineData("..")]
+        public static void GetSafeLeafFileName_RejectsUnusableLeaf(string? input)
+        {
+            Assert.Null(PathHelper.GetSafeLeafFileName(input));
+        }
+
+        [Fact]
+        public static void IsContainedIn_ChildPath_ReturnsTrue()
+        {
+            var root = Path.Combine(Path.GetTempPath(), "root");
+            var child = Path.Combine(root, "sub", "file.txt");
+            Assert.True(PathHelper.IsContainedIn(root, child));
+        }
+
+        [Fact]
+        public static void IsContainedIn_RootItself_ReturnsTrue()
+        {
+            var root = Path.Combine(Path.GetTempPath(), "root");
+            Assert.True(PathHelper.IsContainedIn(root, root));
+        }
+
+        [Fact]
+        public static void IsContainedIn_TraversalEscape_ReturnsFalse()
+        {
+            var root = Path.Combine(Path.GetTempPath(), "root");
+            var escape = Path.Combine(root, "..", "..", "etc", "passwd");
+            Assert.False(PathHelper.IsContainedIn(root, escape));
+        }
+
+        [Fact]
+        public static void IsContainedIn_SiblingPrefixCollision_ReturnsFalse()
+        {
+            // "/var/data" must not be accepted as a parent of "/var/dataset".
+            var root = Path.Combine(Path.GetTempPath(), "data");
+            var sibling = Path.Combine(Path.GetTempPath(), "dataset", "file.txt");
+            Assert.False(PathHelper.IsContainedIn(root, sibling));
+        }
+    }
+}
-- 
cgit v1.2.3


From 62a5ded9205b10ddaef60ce3e05bf80e79f4c742 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Fri, 17 Jul 2026 17:04:31 +0200
Subject: Prevent unauthenticated re-run of the startup wizard on
 misconfiguration

---
 Emby.Server.Implementations/ApplicationHost.cs     | 22 +++++++
 Jellyfin.Api/Controllers/StartupController.cs      |  5 ++
 .../Controllers/StartupControllerTests.cs          | 70 ++++++++++++++++++++++
 3 files changed, 97 insertions(+)
 create mode 100644 tests/Jellyfin.Api.Tests/Controllers/StartupControllerTests.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/ApplicationHost.cs b/Emby.Server.Implementations/ApplicationHost.cs
index 69e23bcb63..0c1c7d3f5b 100644
--- a/Emby.Server.Implementations/ApplicationHost.cs
+++ b/Emby.Server.Implementations/ApplicationHost.cs
@@ -39,6 +39,8 @@ using Emby.Server.Implementations.SyncPlay;
 using Emby.Server.Implementations.TV;
 using Emby.Server.Implementations.Updates;
 using Jellyfin.Api.Helpers;
+using Jellyfin.Data;
+using Jellyfin.Database.Implementations.Enums;
 using Jellyfin.Drawing;
 using Jellyfin.MediaEncoding.Hls.Playlist;
 using Jellyfin.Networking.Manager;
@@ -417,6 +419,8 @@ namespace Emby.Server.Implementations
         {
             Logger.LogInformation("Running startup tasks");
 
+            EnsureStartupWizardIntegrity();
+
             Resolve<ITaskManager>().AddTasks(GetExports<IScheduledTask>(false));
 
             ConfigurationManager.ConfigurationUpdated += OnConfigurationUpdated;
@@ -436,6 +440,24 @@ namespace Emby.Server.Implementations
             return Task.CompletedTask;
         }
 
+        private void EnsureStartupWizardIntegrity()
+        {
+            if (ConfigurationManager.CommonConfiguration.IsStartupWizardCompleted)
+            {
+                return;
+            }
+
+            var hasConfiguredAdministrator = Resolve<IUserManager>().GetUsers()
+                .Any(user => user.HasPermission(PermissionKind.IsAdministrator) && !string.IsNullOrEmpty(user.Password));
+
+            if (hasConfiguredAdministrator)
+            {
+                Logger.LogWarning("The startup wizard is marked incomplete but a configured administrator already exists. Marking setup as completed to prevent the unauthenticated setup endpoints from being reachable.");
+                ConfigurationManager.Configuration.IsStartupWizardCompleted = true;
+                ConfigurationManager.SaveConfiguration();
+            }
+        }
+
         /// <inheritdoc/>
         public void Init(IServiceCollection serviceCollection)
         {
diff --git a/Jellyfin.Api/Controllers/StartupController.cs b/Jellyfin.Api/Controllers/StartupController.cs
index fa6d9efe36..47c8f21241 100644
--- a/Jellyfin.Api/Controllers/StartupController.cs
+++ b/Jellyfin.Api/Controllers/StartupController.cs
@@ -140,6 +140,11 @@ public class StartupController : BaseJellyfinApiController
             return NotFound();
         }
 
+        if (!string.IsNullOrEmpty(user.Password))
+        {
+            return Forbid();
+        }
+
         if (string.IsNullOrWhiteSpace(startupUserDto.Password))
         {
             return BadRequest("Password must not be empty");
diff --git a/tests/Jellyfin.Api.Tests/Controllers/StartupControllerTests.cs b/tests/Jellyfin.Api.Tests/Controllers/StartupControllerTests.cs
new file mode 100644
index 0000000000..bad11a9257
--- /dev/null
+++ b/tests/Jellyfin.Api.Tests/Controllers/StartupControllerTests.cs
@@ -0,0 +1,70 @@
+using System.Threading.Tasks;
+using Jellyfin.Api.Controllers;
+using Jellyfin.Api.Models.StartupDtos;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Server.Implementations.Users;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Library;
+using Microsoft.AspNetCore.Mvc;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Api.Tests.Controllers;
+
+public class StartupControllerTests
+{
+    private readonly StartupController _subject;
+    private readonly Mock<IUserManager> _mockUserManager;
+    private readonly Mock<IServerConfigurationManager> _mockConfig;
+
+    public StartupControllerTests()
+    {
+        _mockUserManager = new Mock<IUserManager>();
+        _mockConfig = new Mock<IServerConfigurationManager>();
+        _subject = new StartupController(_mockConfig.Object, _mockUserManager.Object);
+    }
+
+    private static User CreateUser()
+        => new User(
+            "jellyfin",
+            typeof(DefaultAuthenticationProvider).FullName!,
+            typeof(DefaultPasswordResetProvider).FullName!);
+
+    [Fact]
+    public async Task UpdateStartupUser_WhenNoUserExists_ReturnsNotFound()
+    {
+        _mockUserManager.Setup(m => m.GetFirstUser()).Returns((User?)null);
+
+        var result = await _subject.UpdateStartupUser(new StartupUserDto { Name = "admin", Password = "pw" });
+
+        Assert.IsType<NotFoundResult>(result);
+    }
+
+    [Fact]
+    public async Task UpdateStartupUser_WhenPasswordAlreadyConfigured_ReturnsForbidden()
+    {
+        var user = CreateUser();
+        user.Password = "already-set-hash";
+        _mockUserManager.Setup(m => m.GetFirstUser()).Returns(user);
+
+        var result = await _subject.UpdateStartupUser(new StartupUserDto { Name = "attacker", Password = "new-pw" });
+
+        // The startup wizard must never overwrite the password of an already-provisioned
+        // account, even if IsStartupWizardCompleted has been cleared.
+        Assert.IsType<ForbidResult>(result);
+        _mockUserManager.Verify(m => m.ChangePassword(It.IsAny<System.Guid>(), It.IsAny<string>()), Times.Never);
+    }
+
+    [Fact]
+    public async Task UpdateStartupUser_WhenNoPasswordYet_SetsPassword()
+    {
+        var user = CreateUser();
+        Assert.True(string.IsNullOrEmpty(user.Password));
+        _mockUserManager.Setup(m => m.GetFirstUser()).Returns(user);
+
+        var result = await _subject.UpdateStartupUser(new StartupUserDto { Name = "jellyfin", Password = "first-pw" });
+
+        Assert.IsType<NoContentResult>(result);
+        _mockUserManager.Verify(m => m.ChangePassword(user.Id, "first-pw"), Times.Once);
+    }
+}
-- 
cgit v1.2.3


From 3321a0cf09f24626263527f736345f1d7cb93fa1 Mon Sep 17 00:00:00 2001
From: CHO-HSUN-TE <ousi4706@gmail.com>
Date: Fri, 17 Jul 2026 16:26:48 -0400
Subject: Translated using Weblate (Chinese (Traditional Han script))
 Translation: Jellyfin/Jellyfin Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/zh_Hant/

---
 Emby.Server.Implementations/Localization/Core/zh-TW.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/zh-TW.json b/Emby.Server.Implementations/Localization/Core/zh-TW.json
index 5dace3b0b7..4e0dff87b9 100644
--- a/Emby.Server.Implementations/Localization/Core/zh-TW.json
+++ b/Emby.Server.Implementations/Localization/Core/zh-TW.json
@@ -106,5 +106,7 @@
     "TaskMoveTrickplayImages": "遷移快轉縮圖位置",
     "TaskMoveTrickplayImagesDescription": "根據媒體庫的設定遷移快轉縮圖的檔案。",
     "CleanupUserDataTask": "用戶資料清理工作",
-    "CleanupUserDataTaskDescription": "從用戶資料中清除已被刪除超過 90 天的媒體的相關資料。"
+    "CleanupUserDataTaskDescription": "從用戶資料中清除已被刪除超過 90 天的媒體的相關資料。",
+    "Original": "原作",
+    "LyricDownloadFailureFromForItem": "無法從 {0} 下載 {1} 的歌詞"
 }
-- 
cgit v1.2.3


From 5e946a45eea0a462afb332a49f1b986854269e55 Mon Sep 17 00:00:00 2001
From: krvi <karivika@hotmail.com>
Date: Sat, 18 Jul 2026 11:10:16 -0400
Subject: Translated using Weblate (Faroese) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/fo/

---
 .../Localization/Core/fo.json                      | 37 ++++++++++++++++++++--
 1 file changed, 35 insertions(+), 2 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/fo.json b/Emby.Server.Implementations/Localization/Core/fo.json
index 4fb9f4329c..e4e5dcf0e5 100644
--- a/Emby.Server.Implementations/Localization/Core/fo.json
+++ b/Emby.Server.Implementations/Localization/Core/fo.json
@@ -1,7 +1,7 @@
 {
     "Artists": "Listafólk",
     "Collections": "Søvn",
-    "Default": "Sjálvgildi",
+    "Default": "Forsett",
     "External": "Ytri",
     "Genres": "Greinar",
     "AppDeviceValues": "App: {0}, Eind: {1}",
@@ -12,5 +12,38 @@
     "Forced": "Kravt",
     "FailedLoginAttemptWithUserName": "Miseydnað innritanarroynd frá {0}",
     "HeaderFavoriteEpisodes": "Yndispartar",
-    "LabelIpAddressValue": "IP atsetur: {0}"
+    "LabelIpAddressValue": "IP-atsetur: {0}",
+    "AuthenticationSucceededWithUserName": "{0} varð samgildur",
+    "HeaderFavoriteShows": "Yndisrøðir",
+    "HeaderLiveTV": "Beinleiðis sjónvarp",
+    "HearingImpaired": "Hoyrnarveik",
+    "Inherit": "Arvar",
+    "LabelRunningTimeValue": "Spælitíð: {0}",
+    "Latest": "Seinastu",
+    "LyricDownloadFailureFromForItem": "Miseydnaðist at niðurtakað sangtekst fyri {1} frá {0}",
+    "NameInstallFailed": "{0} innlegging miseydnaðist",
+    "NewVersionIsAvailable": "Ein nýggj útgáva av Jellyfin ambætaranum er tøk.",
+    "NotificationOptionNewLibraryContent": "Nýtt tilfar innlagt",
+    "NotificationOptionPluginInstalled": "Ískoytisforrit innlagt",
+    "NotificationOptionPluginUninstalled": "Ískoytisforrit strikað",
+    "NotificationOptionPluginUpdateInstalled": "Ískoytisforrit dagført",
+    "NotificationOptionUserLockedOut": "Brúkari útihýstur",
+    "Photos": "Ljósmyndir",
+    "PluginInstalledWithName": "{0} var innlagt",
+    "PluginUninstalledWithName": "{0} var strikað",
+    "PluginUpdatedWithName": "{0} varð dagført",
+    "Shows": "Røðir",
+    "SubtitleDownloadFailureFromForItem": "Miseydnaðist at niðurtakað undirtekstir til {1} frá {0}",
+    "TvShows": "Sjónvarpsrøðir",
+    "UserCreatedWithName": "Brúkari {0} er stovnaður",
+    "UserDeletedWithName": "Brúkari {0} er strikaður",
+    "UserDownloadingItemWithValues": "{0} niðurtekur {1}",
+    "UserLockedOutWithName": "Brúkari {0} er útihýstur",
+    "VersionNumber": "Útgáva {0}",
+    "TasksLibraryCategory": "Savn",
+    "TaskRefreshLibrary": "Skanna miðlasavn",
+    "TaskCleanLogsDescription": "Strikar gerðalistafílur eldri enn {0} dagar.",
+    "TaskUpdatePlugins": "Dagfør ískoytisforrit",
+    "TaskRefreshChannels": "Endurinnles rásir",
+    "TaskDownloadMissingLyricsDescription": "Niðurtekur sangtekstir"
 }
-- 
cgit v1.2.3


From 6c0eff5b391932edf9833d6f20ca0c2f59764140 Mon Sep 17 00:00:00 2001
From: krvi <karivika@hotmail.com>
Date: Sat, 18 Jul 2026 17:41:10 -0400
Subject: Translated using Weblate (Faroese) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/fo/

---
 Emby.Server.Implementations/Localization/Core/fo.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/fo.json b/Emby.Server.Implementations/Localization/Core/fo.json
index e4e5dcf0e5..046762fefb 100644
--- a/Emby.Server.Implementations/Localization/Core/fo.json
+++ b/Emby.Server.Implementations/Localization/Core/fo.json
@@ -45,5 +45,6 @@
     "TaskCleanLogsDescription": "Strikar gerðalistafílur eldri enn {0} dagar.",
     "TaskUpdatePlugins": "Dagfør ískoytisforrit",
     "TaskRefreshChannels": "Endurinnles rásir",
-    "TaskDownloadMissingLyricsDescription": "Niðurtekur sangtekstir"
+    "TaskDownloadMissingLyricsDescription": "Niðurtekur sangtekstir",
+    "Movies": "Filmar"
 }
-- 
cgit v1.2.3


From 2b6302c06e0acb2c4f99512ab574258553724ed8 Mon Sep 17 00:00:00 2001
From: Milo Ivir <mail@milotype.de>
Date: Sun, 19 Jul 2026 06:33:48 -0400
Subject: Translated using Weblate (Croatian) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/hr/

---
 Emby.Server.Implementations/Localization/Core/hr.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/hr.json b/Emby.Server.Implementations/Localization/Core/hr.json
index 8794339fb1..442c26b30b 100644
--- a/Emby.Server.Implementations/Localization/Core/hr.json
+++ b/Emby.Server.Implementations/Localization/Core/hr.json
@@ -107,5 +107,6 @@
     "TaskMoveTrickplayImagesDescription": "Premješta postojeće datoteke brzog pregledavanja u postavke biblioteke.",
     "CleanupUserDataTask": "Zadatak čišćenja korisničkih podataka",
     "CleanupUserDataTaskDescription": "Briše sve korisničke podatke (stanje gledanja, status favorita itd.) s medija koji više nisu prisutni najmanje 90 dana.",
-    "Original": "Original"
+    "Original": "Original",
+    "LyricDownloadFailureFromForItem": "Preuzimanje tekstova pjesmi od {0} za {1} nije uspjelo"
 }
-- 
cgit v1.2.3


From cc44f333b6d3588fcfe5d0271c8dea2240acf4c3 Mon Sep 17 00:00:00 2001
From: krvi <27792771+krvi@users.noreply.github.com>
Date: Sun, 19 Jul 2026 15:43:00 -0400
Subject: Translated using Weblate (Faroese) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/fo/

---
 Emby.Server.Implementations/Localization/Core/fo.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/fo.json b/Emby.Server.Implementations/Localization/Core/fo.json
index 046762fefb..8605a752db 100644
--- a/Emby.Server.Implementations/Localization/Core/fo.json
+++ b/Emby.Server.Implementations/Localization/Core/fo.json
@@ -46,5 +46,7 @@
     "TaskUpdatePlugins": "Dagfør ískoytisforrit",
     "TaskRefreshChannels": "Endurinnles rásir",
     "TaskDownloadMissingLyricsDescription": "Niðurtekur sangtekstir",
-    "Movies": "Filmar"
+    "Movies": "Filmar",
+    "MixedContent": "Blandað innihald",
+    "Music": "Tónleikur"
 }
-- 
cgit v1.2.3


From ffe075650c11141667ccef04575d17b2c2266792 Mon Sep 17 00:00:00 2001
From: theguymadmax <theguymadmax@proton.me>
Date: Mon, 20 Jul 2026 06:23:20 -0400
Subject: Add TVDB provider ID support for movies (#17255)

Add TVDB provider ID support for movies
---
 .../Library/Resolvers/Movies/MovieResolver.cs       | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
index 68b66ab7f5..80375ae12d 100644
--- a/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
@@ -376,15 +376,24 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                 // We need to only look at the name of this actual item (not parents)
                 var justName = item.IsInMixedFolder ? Path.GetFileName(item.Path.AsSpan()) : Path.GetFileName(item.ContainingFolderPath.AsSpan());
 
-                var tmdbid = justName.GetAttributeValue("tmdbid");
+                // The fallback filename is only used when the item isn't in a mixed folder
+                var fileName = item.IsInMixedFolder ? ReadOnlySpan<char>.Empty : Path.GetFileName(item.Path.AsSpan());
 
-                // If not in a mixed folder and ID not found in folder path, check filename
-                if (string.IsNullOrEmpty(tmdbid) && !item.IsInMixedFolder)
+                item.TrySetProviderId(MetadataProvider.Tmdb, GetIdFromNameOrPath(justName, fileName, "tmdbid"));
+                item.TrySetProviderId(MetadataProvider.Tvdb, GetIdFromNameOrPath(justName, fileName, "tvdbid"));
+
+                string GetIdFromNameOrPath(ReadOnlySpan<char> name, ReadOnlySpan<char> fallbackName, string attribute)
                 {
-                    tmdbid = Path.GetFileName(item.Path.AsSpan()).GetAttributeValue("tmdbid");
-                }
+                    var id = name.GetAttributeValue(attribute);
+
+                    // If not in a mixed folder and ID not found in folder path, check filename
+                    if (string.IsNullOrEmpty(id) && !item.IsInMixedFolder)
+                    {
+                        id = fallbackName.GetAttributeValue(attribute);
+                    }
 
-                item.TrySetProviderId(MetadataProvider.Tmdb, tmdbid);
+                    return id;
+                }
 
                 if (!string.IsNullOrEmpty(item.Path))
                 {
-- 
cgit v1.2.3


From 2cd2f36fe4912cb465cf5e78a055463f8a5c44a9 Mon Sep 17 00:00:00 2001
From: 854562 <44002186+854562@users.noreply.github.com>
Date: Mon, 20 Jul 2026 22:00:10 +0200
Subject: Extract truncation logic to helper and add tests

---
 .../Localization/LocalizationManager.cs            | 18 ++++++++++++
 .../Item/MediaStreamRepository.cs                  |  6 +---
 .../Probing/ProbeResultNormalizer.cs               |  8 ++---
 .../Globalization/ILocalizationManager.cs          |  8 +++++
 .../Localization/LocalizationManagerTests.cs       | 34 ++++++++++++++++++++++
 5 files changed, 63 insertions(+), 11 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/LocalizationManager.cs b/Emby.Server.Implementations/Localization/LocalizationManager.cs
index 843e35afcc..068dde639e 100644
--- a/Emby.Server.Implementations/Localization/LocalizationManager.cs
+++ b/Emby.Server.Implementations/Localization/LocalizationManager.cs
@@ -261,6 +261,24 @@ namespace Emby.Server.Implementations.Localization
                 _cultures);
         }
 
+        /// <inheritdoc />
+        public string? GetLanguageDisplayName(string language)
+        {
+            if (string.IsNullOrEmpty(language))
+            {
+                return null;
+            }
+
+            var displayName = FindLanguageInfo(language)?.DisplayName;
+            if (displayName is null)
+            {
+                return null;
+            }
+
+            // Truncate at the first delimiter to avoid cluttered display names
+            return displayName.Split([';', ','], StringSplitOptions.None)[0].Trim();
+        }
+
         /// <inheritdoc />
         public IReadOnlyList<CountryInfo> GetCountries()
         {
diff --git a/Jellyfin.Server.Implementations/Item/MediaStreamRepository.cs b/Jellyfin.Server.Implementations/Item/MediaStreamRepository.cs
index 17cfdffe84..a25629132b 100644
--- a/Jellyfin.Server.Implementations/Item/MediaStreamRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/MediaStreamRepository.cs
@@ -172,11 +172,7 @@ public class MediaStreamRepository : IMediaStreamRepository
 
             if (!string.IsNullOrEmpty(dto.Language))
             {
-                var culture = _localization.FindLanguageInfo(dto.Language);
-                // Truncate at the first delimiter to avoid cluttered display names
-                dto.LocalizedLanguage = culture?.DisplayName is { } name
-                    ? name.Split([';', ','])[0].Trim()
-                    : null;
+                dto.LocalizedLanguage = _localization.GetLanguageDisplayName(dto.Language);
             }
 
             if (dto.Type is MediaStreamType.Audio)
diff --git a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
index a9c37c0025..449c18a306 100644
--- a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
+++ b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
@@ -732,9 +732,7 @@ namespace MediaBrowser.MediaEncoding.Probing
                 stream.LocalizedOriginal = _localization.GetLocalizedString("Original");
                 if (!string.IsNullOrEmpty(stream.Language))
                 {
-                    stream.LocalizedLanguage = _localization.FindLanguageInfo(stream.Language)?.DisplayName is { } name
-                        ? name.Split([';', ','])[0].Trim()
-                        : null;
+                    stream.LocalizedLanguage = _localization.GetLanguageDisplayName(stream.Language);
                 }
 
                 stream.Channels = streamInfo.Channels;
@@ -776,9 +774,7 @@ namespace MediaBrowser.MediaEncoding.Probing
                 stream.LocalizedHearingImpaired = _localization.GetLocalizedString("HearingImpaired");
                 if (!string.IsNullOrEmpty(stream.Language))
                 {
-                    stream.LocalizedLanguage = _localization.FindLanguageInfo(stream.Language)?.DisplayName is { } name
-                        ? name.Split([';', ','])[0].Trim()
-                        : null;
+                    stream.LocalizedLanguage = _localization.GetLanguageDisplayName(stream.Language);
                 }
 
                 if (string.IsNullOrEmpty(stream.Title))
diff --git a/MediaBrowser.Model/Globalization/ILocalizationManager.cs b/MediaBrowser.Model/Globalization/ILocalizationManager.cs
index 7ad240abfb..0fff70c4e0 100644
--- a/MediaBrowser.Model/Globalization/ILocalizationManager.cs
+++ b/MediaBrowser.Model/Globalization/ILocalizationManager.cs
@@ -72,6 +72,14 @@ public interface ILocalizationManager
     /// <returns>The correct <see cref="CultureDto" /> for the given language.</returns>
     CultureDto? FindLanguageInfo(string language);
 
+    /// <summary>
+    /// Gets a human-readable display name for the given language code.
+    /// Truncates at the first semicolon or comma to avoid cluttered ISO-639-2 names.
+    /// </summary>
+    /// <param name="language">An ISO language code.</param>
+    /// <returns>The display name, or null if not found.</returns>
+    string? GetLanguageDisplayName(string language);
+
     /// <summary>
     /// Returns the language in ISO 639-2/T when the input is ISO 639-2/B.
     /// </summary>
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
index 3b8fe5ca60..b608d3ea49 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
@@ -119,6 +119,40 @@ namespace Jellyfin.Server.Implementations.Tests.Localization
             Assert.Equal(code, culture.ThreeLetterISOLanguageName);
         }
 
+        [Theory]
+        [InlineData("ell", "Greek")] // Comma truncation
+        [InlineData("nld", "Dutch")] // Semicolon truncation
+        [InlineData("ron", "Romanian")] // Semicolon truncation, multiple
+        [InlineData("eng", "English")] // No truncation
+        [InlineData("zh-CN", "Chinese (Simplified)")] // No truncation, with parentheses
+        public async Task GetLanguageDisplayName_DelimitedName_ReturnsTruncatedName(string language, string expected)
+        {
+            var localizationManager = Setup(new ServerConfiguration
+            {
+                UICulture = "en-US"
+            });
+            await localizationManager.LoadAll();
+
+            var result = localizationManager.GetLanguageDisplayName(language);
+            Assert.Equal(expected, result);
+        }
+
+        [Theory]
+        [InlineData(null)]
+        [InlineData("")]
+        [InlineData("xyz")]
+        public async Task GetLanguageDisplayName_InvalidInput_ReturnsNull(string? language)
+        {
+            var localizationManager = Setup(new ServerConfiguration
+            {
+                UICulture = "en-US"
+            });
+            await localizationManager.LoadAll();
+
+            var result = localizationManager.GetLanguageDisplayName(language!);
+            Assert.Null(result);
+        }
+
         [Fact]
         public async Task GetParentalRatings_Default_Success()
         {
-- 
cgit v1.2.3


From 9d5aedba5fd786ef6a3775a6953cc6759545e2d9 Mon Sep 17 00:00:00 2001
From: Shed Shedson <hjorturthorgeirs+hmp1devq@gmail.com>
Date: Mon, 20 Jul 2026 06:30:49 -0400
Subject: Translated using Weblate (Icelandic) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/is/

---
 Emby.Server.Implementations/Localization/Core/is.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/is.json b/Emby.Server.Implementations/Localization/Core/is.json
index 44e057e4de..825ad3084e 100644
--- a/Emby.Server.Implementations/Localization/Core/is.json
+++ b/Emby.Server.Implementations/Localization/Core/is.json
@@ -106,5 +106,7 @@
     "CleanupUserDataTaskDescription": "Hreinsar öll notendagögn (spilunarstöðu, uppáhöld o.s.frv.) um gögn sem hafa ekki verið til staðar í að lámarki 90 daga.",
     "LyricDownloadFailureFromForItem": "Ekki tókst að niðurhala texta frá {0} fyrir {1}",
     "Original": "Upprunaleg",
-    "TaskExtractMediaSegmentsDescription": "Sækir myndbúta úr viðbótum þar sem MediaSegment er virkt."
+    "TaskExtractMediaSegmentsDescription": "Sækir myndbúta úr viðbótum þar sem MediaSegment er virkt.",
+    "TaskMoveTrickplayImages": "Flytja geymslustað fyrir Trickplay-myndir",
+    "TaskMoveTrickplayImagesDescription": "Flytur fyrirliggjandi Trickplay-skrár í samræmi við stillingar safnsins."
 }
-- 
cgit v1.2.3


From b4090bdcb24bb99087a492bdbc370878738d5086 Mon Sep 17 00:00:00 2001
From: aivarsse <aivars.sesters@inbox.lv>
Date: Tue, 21 Jul 2026 10:13:23 -0400
Subject: Translated using Weblate (Latvian) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/lv/

---
 Emby.Server.Implementations/Localization/Core/lv.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/lv.json b/Emby.Server.Implementations/Localization/Core/lv.json
index 4a1b248e76..76fa9e3cf7 100644
--- a/Emby.Server.Implementations/Localization/Core/lv.json
+++ b/Emby.Server.Implementations/Localization/Core/lv.json
@@ -107,5 +107,6 @@
     "TaskDownloadMissingLyricsDescription": "Lejupielādēt vārdus dziesmām",
     "CleanupUserDataTask": "Lietotāju datu tīrīšanas uzdevums",
     "CleanupUserDataTaskDescription": "Notīra visus lietotāja datus (skatīšanās stāvokļus, favorītu statusi utt.) no medijiem, kas vairs nav pieejami vismaz 90 dienas.",
-    "Original": "Oriģināls"
+    "Original": "Oriģināls",
+    "LyricDownloadFailureFromForItem": "Dziesmu vārdi nevarēja tikt lejupielādēti no {0} priekš {1}"
 }
-- 
cgit v1.2.3


From ca1f7af4458feffa7b9800d536b536e544fc4b7c Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Tue, 21 Jul 2026 20:27:04 +0200
Subject: Fix incorrect year on local trailers

---
 .../Library/Resolvers/ExtraResolver.cs             |  4 +--
 .../Library/Resolvers/GenericVideoResolver.cs      | 13 ++++++-
 MediaBrowser.Controller/Entities/BaseItem.cs       | 13 +++++++
 .../Library/LibraryManager/FindExtrasTests.cs      | 41 ++++++++++++++++++++++
 4 files changed, 68 insertions(+), 3 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/Resolvers/ExtraResolver.cs b/Emby.Server.Implementations/Library/Resolvers/ExtraResolver.cs
index b9f9f29723..6ba4a7bce6 100644
--- a/Emby.Server.Implementations/Library/Resolvers/ExtraResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/ExtraResolver.cs
@@ -32,8 +32,8 @@ namespace Emby.Server.Implementations.Library.Resolvers
             : base(logger, namingOptions, directoryService)
         {
             _namingOptions = namingOptions;
-            _trailerResolvers = new IItemResolver[] { new GenericVideoResolver<Trailer>(logger, namingOptions, directoryService) };
-            _videoResolvers = new IItemResolver[] { this };
+            _trailerResolvers = [new GenericVideoResolver<Trailer>(logger, namingOptions, directoryService, parseName: true)];
+            _videoResolvers = [this];
         }
 
         protected override Video Resolve(ItemResolveArgs args)
diff --git a/Emby.Server.Implementations/Library/Resolvers/GenericVideoResolver.cs b/Emby.Server.Implementations/Library/Resolvers/GenericVideoResolver.cs
index ba320266a4..b3bdea704a 100644
--- a/Emby.Server.Implementations/Library/Resolvers/GenericVideoResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/GenericVideoResolver.cs
@@ -2,6 +2,7 @@
 
 using Emby.Naming.Common;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using Microsoft.Extensions.Logging;
 
@@ -14,15 +15,25 @@ namespace Emby.Server.Implementations.Library.Resolvers
     public class GenericVideoResolver<T> : BaseVideoResolver<T>
         where T : Video, new()
     {
+        private readonly bool _parseName;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="GenericVideoResolver{T}"/> class.
         /// </summary>
         /// <param name="logger">The logger.</param>
         /// <param name="namingOptions">The naming options.</param>
         /// <param name="directoryService">The directory service.</param>
-        public GenericVideoResolver(ILogger logger, NamingOptions namingOptions, IDirectoryService directoryService)
+        /// <param name="parseName">Whether to parse the file name for metadata such as the year.</param>
+        public GenericVideoResolver(ILogger logger, NamingOptions namingOptions, IDirectoryService directoryService, bool parseName = false)
             : base(logger, namingOptions, directoryService)
         {
+            _parseName = parseName;
+        }
+
+        /// <inheritdoc />
+        protected override T Resolve(ItemResolveArgs args)
+        {
+            return ResolveVideo<T>(args, _parseName);
         }
     }
 }
diff --git a/MediaBrowser.Controller/Entities/BaseItem.cs b/MediaBrowser.Controller/Entities/BaseItem.cs
index 49a4ed4bf6..cc2a425a4d 100644
--- a/MediaBrowser.Controller/Entities/BaseItem.cs
+++ b/MediaBrowser.Controller/Entities/BaseItem.cs
@@ -1557,6 +1557,19 @@ namespace MediaBrowser.Controller.Entities
 
                 i.OwnerId = ownerId;
                 i.ParentId = Guid.Empty;
+
+                // Extras (e.g. trailers) frequently have no reliable date metadata of their own and
+                // would otherwise fall back to the file's container creation date. Inherit the owner's
+                // year/premiere date when the extra doesn't have one, so it stays consistent with the
+                // media it belongs to. Setting it before the refresh means the media info provider
+                // won't overwrite it from the file creation date.
+                if (!i.ProductionYear.HasValue && item.ProductionYear.HasValue)
+                {
+                    i.ProductionYear = item.ProductionYear;
+                    i.PremiereDate ??= item.PremiereDate;
+                    subOptions.ForceSave = true;
+                }
+
                 return RefreshMetadataForOwnedItem(i, true, subOptions, cancellationToken);
             });
 
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/FindExtrasTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/FindExtrasTests.cs
index 562711337f..07c537aee1 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/FindExtrasTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManager/FindExtrasTests.cs
@@ -305,6 +305,47 @@ public class FindExtrasTests
         Assert.Empty(extras);
     }
 
+    [Fact]
+    public void FindExtras_TrailerWithYearInFilename_SetsProductionYearFromFilename()
+    {
+        var owner = new Movie { Name = "Up", Path = "/movies/Up/Up.mkv" };
+        var paths = new List<string>
+        {
+            "/movies/Up/Up.mkv",
+            "/movies/Up/trailers"
+        };
+
+        _fileSystemMock.Setup(f => f.GetFiles(
+                "/movies/Up/trailers",
+                It.IsAny<string[]>(),
+                false,
+                false))
+            .Returns(new List<FileSystemMetadata>
+            {
+                new()
+                {
+                    FullName = "/movies/Up/trailers/Trailer 1 (2013).mkv",
+                    Name = "Trailer 1 (2013).mkv",
+                    IsDirectory = false
+                }
+            }).Verifiable();
+
+        var files = paths.Select(p => new FileSystemMetadata
+        {
+            FullName = p,
+            Name = Path.GetFileName(p),
+            IsDirectory = !Path.HasExtension(p)
+        }).ToList();
+
+        var extras = _libraryManager.FindExtras(owner, files, new DirectoryService(_fileSystemMock.Object)).ToList();
+
+        _fileSystemMock.Verify();
+        var trailer = Assert.Single(extras);
+        Assert.Equal(ExtraType.Trailer, trailer.ExtraType);
+        Assert.Equal(typeof(Trailer), trailer.GetType());
+        Assert.Equal(2013, trailer.ProductionYear);
+    }
+
     [Fact]
     public void FindExtras_SeriesWithTrailers_FindsCorrectExtras()
     {
-- 
cgit v1.2.3


From 5d580abb08d9d23f54e74050fdaa8fcdbc21571f Mon Sep 17 00:00:00 2001
From: Paolo Antinori <pantinor@redhat.com>
Date: Tue, 21 Jul 2026 08:20:40 +0200
Subject: fix: avoid NRE when sorting by user-dependent keys without a user
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

A query sorted by a user-dependent key (PlayCount, IsFavoriteOrLiked,
DatePlayed, IsPlayed, IsUnplayed) but carrying no User caused a
NullReferenceException inside UserDataManager.GetUserData, surfacing as
"Failed to compare two elements in the array" (InvalidOperationException
wrapping the NRE from the LINQ sort) and 500-ing the /Items request.

Root cause: LibraryManager.GetComparer assigned comparer.User = user
without a null guard, so PlayCountComparer.GetValue called
UserDataManager.GetUserData(null, item), dereferencing user.Id.

Two-part fix:
- LibraryManager.GetComparer: when user is null and the sort key requires a
  user (IUserBaseItemComparer), substitute the SortName comparer so the
  result stays deterministic instead of 500-ing. SortName is the project's
  canonical tiebreaker (ItemsController injects it for album-by-artist).
- UserDataManager.GetUserData: ArgumentNullException.ThrowIfNull(user) as
  defense in depth (matches the existing guards on the SaveUserData
  overloads in the same file). On master this overload was rewritten to use
  ResolveUserDataRow, so the NRE dereferences user.Id rather than
  user.InternalId as on the release branch — same bug, different line.

Also fixes DateLastMediaAddedComparer being statically mis-tagged as
IUserBaseItemComparer: its GetDate is static and never reads User, so it
does not need one. Without this, the SortName fallback above would wrongly
engage for DateLastContentAdded on anonymous queries (returning SortName
order instead of date order). Re-tagged to IBaseItemComparer and dropped the
unused User/UserManager/UserDataManager properties.

Tests:
- UserDataManagerTests.GetUserData_NullUser_ThrowsArgumentNullException:
  reproduces the crash (NRE -> now ArgumentNullException). Added to master's
  existing UserDataManagerTests.
- LibraryManagerSortTests.Sort_UserDependentKey_NullUser_FallsBackToSortNameWithoutThrowing:
  Sort with a user-dependent key + null user no longer throws and returns
  items ordered by the SortName fallback (direction preserved).
- LibraryManagerSortTests.Sort_DateLastContentAdded_NullUser_OrdersByDateNotSortName:
  guards that DateLastContentAdded still sorts by date with no user (fixture
  chosen so date-desc and SortName-desc disagree, so a revert is caught).

Full Jellyfin.Server.Implementations.Tests suite: 642 passed, 0 failed.

Fixes #17393
---
 .../Library/LibraryManager.cs                      |   9 +-
 .../Library/UserDataManager.cs                     |   1 +
 .../Sorting/DateLastMediaAddedComparer.cs          |  22 +----
 .../Library/LibraryManagerSortTests.cs             | 101 +++++++++++++++++++++
 .../Library/UserDataManagerTests.cs                |   7 ++
 5 files changed, 118 insertions(+), 22 deletions(-)
 create mode 100644 tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerSortTests.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 3691f4e19d..8d67f0c6c7 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -2315,9 +2315,16 @@ namespace Emby.Server.Implementations.Library
         {
             var comparer = Comparers.FirstOrDefault(c => name == c.Type);
 
-            // If it requires a user, create a new one, and assign the user
+            // User-dependent comparers (IUserBaseItemComparer) need a User. With no user
+            // (anonymous/API-key /Items requests), a user-dependent sort key is a caller contract
+            // violation — throw rather than silently falling back to a different key.
             if (comparer is IUserBaseItemComparer)
             {
+                if (user is null)
+                {
+                    throw new ArgumentException($"Sort key '{name}' requires a user, but none was provided.");
+                }
+
                 var userComparer = (IUserBaseItemComparer)Activator.CreateInstance(comparer.GetType())!; // only null for Nullable<T> instances
 
                 userComparer.User = user;
diff --git a/Emby.Server.Implementations/Library/UserDataManager.cs b/Emby.Server.Implementations/Library/UserDataManager.cs
index f5c41e5670..0680046c11 100644
--- a/Emby.Server.Implementations/Library/UserDataManager.cs
+++ b/Emby.Server.Implementations/Library/UserDataManager.cs
@@ -352,6 +352,7 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public UserItemData? GetUserData(User user, BaseItem item)
         {
+            ArgumentNullException.ThrowIfNull(user);
             var row = ResolveUserDataRow(item, item.UserData?.Where(e => e.UserId.Equals(user.Id)));
             return row is not null ? Map(row) : new UserItemData()
             {
diff --git a/Emby.Server.Implementations/Sorting/DateLastMediaAddedComparer.cs b/Emby.Server.Implementations/Sorting/DateLastMediaAddedComparer.cs
index f10e7fcbb7..4159f8cf7d 100644
--- a/Emby.Server.Implementations/Sorting/DateLastMediaAddedComparer.cs
+++ b/Emby.Server.Implementations/Sorting/DateLastMediaAddedComparer.cs
@@ -3,34 +3,14 @@
 
 using System;
 using Jellyfin.Data.Enums;
-using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Sorting;
 using MediaBrowser.Model.Querying;
 
 namespace Emby.Server.Implementations.Sorting
 {
-    public class DateLastMediaAddedComparer : IUserBaseItemComparer
+    public class DateLastMediaAddedComparer : IBaseItemComparer
     {
-        /// <summary>
-        /// Gets or sets the user.
-        /// </summary>
-        /// <value>The user.</value>
-        public User User { get; set; }
-
-        /// <summary>
-        /// Gets or sets the user manager.
-        /// </summary>
-        /// <value>The user manager.</value>
-        public IUserManager UserManager { get; set; }
-
-        /// <summary>
-        /// Gets or sets the user data manager.
-        /// </summary>
-        /// <value>The user data manager.</value>
-        public IUserDataManager UserDataManager { get; set; }
-
         /// <summary>
         /// Gets the name.
         /// </summary>
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerSortTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerSortTests.cs
new file mode 100644
index 0000000000..9cec9d6736
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerSortTests.cs
@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Emby.Naming.Common;
+using Emby.Server.Implementations.Library;
+using Emby.Server.Implementations.Sorting;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Controller.Resolvers;
+using MediaBrowser.Controller.Sorting;
+using MediaBrowser.Model.IO;
+using Moq;
+using Xunit;
+using BaseItem = MediaBrowser.Controller.Entities.BaseItem;
+
+namespace Jellyfin.Server.Implementations.Tests.Library;
+
+public class LibraryManagerSortTests
+{
+    [Fact]
+    public void Sort_UserDependentKey_NullUser_ThrowsArgumentException()
+    {
+        var libraryManager = CreateLibraryManager(
+            new IBaseItemComparer[] { new PlayCountComparer(), new SortNameComparer() });
+
+        BaseItem[] items =
+        {
+            new Audio { Name = "Zulu", SortName = "Zulu", Id = Guid.NewGuid() },
+            new Audio { Name = "Alpha", SortName = "Alpha", Id = Guid.NewGuid() },
+        };
+
+        // A user-dependent sort key with no user is a caller contract violation — throw,
+        // don't silently fall back to a different key (review feedback on #17395).
+        Assert.Throws<ArgumentException>(() => libraryManager.Sort(
+            items,
+            user: null,
+            new[] { (ItemSortBy.PlayCount, SortOrder.Descending) }).ToArray());
+    }
+
+    [Fact]
+    public void Sort_DateLastContentAdded_NullUser_OrdersByDateNotSortName()
+    {
+        // DateLastMediaAddedComparer does not use User (its GetDate is static), so it must NOT be
+        // treated as a user-dependent comparer: with no user it should still sort by date, not fall
+        // back to SortName.
+        var libraryManager = CreateLibraryManager(
+            new IBaseItemComparer[] { new DateLastMediaAddedComparer(), new SortNameComparer() });
+
+        // Names are chosen so date-descending and SortName-descending DISAGREE: Alpha is newest
+        // (date-desc rank 1), but Zulu sorts last alphabetically (SortName-desc rank 1). If the
+        // comparer were still tagged IUserBaseItemComparer, the null-user SortName fallback would
+        // return [Zulu, Mike, Alpha] and this assertion would fail.
+        BaseItem[] items =
+        {
+            MakeFolder("Alpha", new DateTime(2026, 1, 1)),
+            MakeFolder("Mike", new DateTime(2025, 1, 1)),
+            MakeFolder("Zulu", new DateTime(2024, 1, 1))
+        };
+
+        var sorted = libraryManager.Sort(
+            items,
+            user: null,
+            new[] { (ItemSortBy.DateLastContentAdded, SortOrder.Descending) }).ToArray();
+
+        // Descending by date => newest first: Alpha, Mike, Zulu. (SortName-desc would be Zulu, Mike, Alpha.)
+        Assert.Equal(new[] { "Alpha", "Mike", "Zulu" }, sorted.Select(i => i.Name));
+    }
+
+    private static Folder MakeFolder(string name, DateTime dateLastMediaAdded)
+        => new() { Name = name, Id = Guid.NewGuid(), DateLastMediaAdded = dateLastMediaAdded };
+
+    private static Emby.Server.Implementations.Library.LibraryManager CreateLibraryManager(IReadOnlyCollection<IBaseItemComparer> comparers)
+    {
+        var fixture = new Fixture().Customize(new AutoMoqCustomization());
+        fixture.Register(() => new NamingOptions());
+        var configMock = fixture.Freeze<Mock<IServerConfigurationManager>>();
+        configMock.Setup(c => c.ApplicationPaths.ProgramDataPath).Returns("/data");
+        // BaseItem.SortName/CreateSortName dereference this static; set it so SortName-fallback
+        // paths don't NRE in-process (mirrors AudioResolverTests in the sibling test project).
+        BaseItem.ConfigurationManager ??= configMock.Object;
+        var itemRepository = fixture.Freeze<Mock<IItemRepository>>();
+        itemRepository.Setup(i => i.RetrieveItem(It.IsAny<Guid>())).Returns<BaseItem>(null);
+        var fileSystemMock = fixture.Freeze<Mock<IFileSystem>>();
+        fileSystemMock.Setup(f => f.GetFileInfo(It.IsAny<string>())).Returns<string>(path => new FileSystemMetadata { FullName = path });
+
+        return fixture.Build<Emby.Server.Implementations.Library.LibraryManager>().Do(s => s.AddParts(
+                fixture.Create<IEnumerable<IResolverIgnoreRule>>(),
+                fixture.Create<IEnumerable<IItemResolver>>(),
+                fixture.Create<IEnumerable<IIntroProvider>>(),
+                comparers,
+                fixture.Create<IEnumerable<ILibraryPostScanTask>>()))
+            .Create();
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs
index bd14ca008d..ba3127bc08 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/UserDataManagerTests.cs
@@ -206,4 +206,11 @@ public sealed class UserDataManagerTests : IDisposable
         Assert.Equal(222, result[fossilItem.Id].PlaybackPositionTicks);
         Assert.Equal(333, result[retiredItem.Id].PlaybackPositionTicks);
     }
+
+    [Fact]
+    public void GetUserData_NullUser_ThrowsArgumentNullException()
+    {
+        var item = CreateAudioBook();
+        Assert.Throws<ArgumentNullException>(() => _userDataManager.GetUserData(null!, item));
+    }
 }
-- 
cgit v1.2.3


From 6382563440b69d816639abc2b4d03fca1d35eca2 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Wed, 22 Jul 2026 08:09:33 +0200
Subject: Prefer null checks over HasValue everywhere

---
 Emby.Server.Implementations/Library/LibraryManager.cs         | 4 ++--
 Emby.Server.Implementations/Sorting/PremiereDateComparer.cs   | 2 +-
 Emby.Server.Implementations/Sorting/ProductionYearComparer.cs | 2 +-
 MediaBrowser.Controller/Entities/Movies/Movie.cs              | 2 +-
 MediaBrowser.Controller/Entities/MusicVideo.cs                | 2 +-
 MediaBrowser.Controller/Entities/TV/Series.cs                 | 2 +-
 MediaBrowser.Controller/Entities/Trailer.cs                   | 2 +-
 MediaBrowser.Controller/Entities/UserViewBuilder.cs           | 2 +-
 MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs             | 2 +-
 MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs   | 2 +-
 MediaBrowser.Providers/Manager/MetadataService.cs             | 2 +-
 MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs          | 6 +++---
 MediaBrowser.XbmcMetadata/Savers/ArtistNfoSaver.cs            | 2 +-
 MediaBrowser.XbmcMetadata/Savers/BaseNfoSaver.cs              | 2 +-
 src/Jellyfin.LiveTv/Recordings/RecordingsManager.cs           | 6 +++---
 src/Jellyfin.LiveTv/Recordings/RecordingsMetadataManager.cs   | 2 +-
 16 files changed, 21 insertions(+), 21 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 3691f4e19d..35c47ecb5c 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -3195,11 +3195,11 @@ namespace Emby.Server.Implementations.Library
                     }
                 }
 
-                if (!episode.ProductionYear.HasValue)
+                if (episode.ProductionYear is null)
                 {
                     episode.ProductionYear = episodeInfo.Year;
 
-                    if (episode.ProductionYear.HasValue)
+                    if (episode.ProductionYear is not null)
                     {
                         changed = true;
                     }
diff --git a/Emby.Server.Implementations/Sorting/PremiereDateComparer.cs b/Emby.Server.Implementations/Sorting/PremiereDateComparer.cs
index 8c8b8824f3..30b268bb60 100644
--- a/Emby.Server.Implementations/Sorting/PremiereDateComparer.cs
+++ b/Emby.Server.Implementations/Sorting/PremiereDateComparer.cs
@@ -45,7 +45,7 @@ namespace Emby.Server.Implementations.Sorting
                 return x.PremiereDate.Value;
             }
 
-            if (x.ProductionYear.HasValue)
+            if (x.ProductionYear is not null)
             {
                 try
                 {
diff --git a/Emby.Server.Implementations/Sorting/ProductionYearComparer.cs b/Emby.Server.Implementations/Sorting/ProductionYearComparer.cs
index 9aec87f183..8774bd8d4f 100644
--- a/Emby.Server.Implementations/Sorting/ProductionYearComparer.cs
+++ b/Emby.Server.Implementations/Sorting/ProductionYearComparer.cs
@@ -39,7 +39,7 @@ namespace Emby.Server.Implementations.Sorting
                 return 0;
             }
 
-            if (x.ProductionYear.HasValue)
+            if (x.ProductionYear is not null)
             {
                 return x.ProductionYear.Value;
             }
diff --git a/MediaBrowser.Controller/Entities/Movies/Movie.cs b/MediaBrowser.Controller/Entities/Movies/Movie.cs
index e8817a29cf..8c3ce2ff58 100644
--- a/MediaBrowser.Controller/Entities/Movies/Movie.cs
+++ b/MediaBrowser.Controller/Entities/Movies/Movie.cs
@@ -90,7 +90,7 @@ namespace MediaBrowser.Controller.Entities.Movies
         {
             var hasChanges = base.BeforeMetadataRefresh(replaceAllMetadata);
 
-            if (!ProductionYear.HasValue)
+            if (ProductionYear is null)
             {
                 var info = LibraryManager.ParseName(Name);
 
diff --git a/MediaBrowser.Controller/Entities/MusicVideo.cs b/MediaBrowser.Controller/Entities/MusicVideo.cs
index 237ad5198c..effbf98820 100644
--- a/MediaBrowser.Controller/Entities/MusicVideo.cs
+++ b/MediaBrowser.Controller/Entities/MusicVideo.cs
@@ -40,7 +40,7 @@ namespace MediaBrowser.Controller.Entities
         {
             var hasChanges = base.BeforeMetadataRefresh(replaceAllMetadata);
 
-            if (!ProductionYear.HasValue)
+            if (ProductionYear is null)
             {
                 var info = LibraryManager.ParseName(Name);
 
diff --git a/MediaBrowser.Controller/Entities/TV/Series.cs b/MediaBrowser.Controller/Entities/TV/Series.cs
index 952187c6e1..d9f300ad20 100644
--- a/MediaBrowser.Controller/Entities/TV/Series.cs
+++ b/MediaBrowser.Controller/Entities/TV/Series.cs
@@ -507,7 +507,7 @@ namespace MediaBrowser.Controller.Entities.TV
         {
             var hasChanges = base.BeforeMetadataRefresh(replaceAllMetadata);
 
-            if (!ProductionYear.HasValue)
+            if (ProductionYear is null)
             {
                 var info = LibraryManager.ParseName(Name);
 
diff --git a/MediaBrowser.Controller/Entities/Trailer.cs b/MediaBrowser.Controller/Entities/Trailer.cs
index 939709215c..a2465eedf0 100644
--- a/MediaBrowser.Controller/Entities/Trailer.cs
+++ b/MediaBrowser.Controller/Entities/Trailer.cs
@@ -49,7 +49,7 @@ namespace MediaBrowser.Controller.Entities
         {
             var hasChanges = base.BeforeMetadataRefresh(replaceAllMetadata);
 
-            if (!ProductionYear.HasValue)
+            if (ProductionYear is null)
             {
                 var info = LibraryManager.ParseName(Name);
 
diff --git a/MediaBrowser.Controller/Entities/UserViewBuilder.cs b/MediaBrowser.Controller/Entities/UserViewBuilder.cs
index c57ed2faf8..9ba103cc8b 100644
--- a/MediaBrowser.Controller/Entities/UserViewBuilder.cs
+++ b/MediaBrowser.Controller/Entities/UserViewBuilder.cs
@@ -730,7 +730,7 @@ namespace MediaBrowser.Controller.Entities
             // Apply year filter
             if (query.Years.Length > 0)
             {
-                if (!(item.ProductionYear.HasValue && query.Years.Contains(item.ProductionYear.Value)))
+                if (item.ProductionYear is null || !query.Years.Contains(item.ProductionYear.Value))
                 {
                     return false;
                 }
diff --git a/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs b/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
index b0f51aec71..bc184d82fb 100644
--- a/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
+++ b/MediaBrowser.LocalMetadata/Savers/BaseXmlSaver.cs
@@ -277,7 +277,7 @@ namespace MediaBrowser.LocalMetadata.Savers
                 await writer.WriteElementStringAsync(null, "Rating", null, item.CommunityRating.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
             }
 
-            if (item.ProductionYear.HasValue && item is not Person)
+            if (item.ProductionYear is not null && item is not Person)
             {
                 await writer.WriteElementStringAsync(null, "ProductionYear", null, item.ProductionYear.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
             }
diff --git a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
index 989701350c..4d2f683a0e 100644
--- a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
+++ b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
@@ -189,7 +189,7 @@ namespace MediaBrowser.MediaEncoding.Probing
             }
 
             // Guess ProductionYear from PremiereDate if missing
-            if (!info.ProductionYear.HasValue && info.PremiereDate.HasValue)
+            if (info.ProductionYear is null && info.PremiereDate is not null)
             {
                 info.ProductionYear = info.PremiereDate.Value.Year;
             }
diff --git a/MediaBrowser.Providers/Manager/MetadataService.cs b/MediaBrowser.Providers/Manager/MetadataService.cs
index a438a94c40..f09c4c876c 100644
--- a/MediaBrowser.Providers/Manager/MetadataService.cs
+++ b/MediaBrowser.Providers/Manager/MetadataService.cs
@@ -1114,7 +1114,7 @@ namespace MediaBrowser.Providers.Manager
                 target.PremiereDate = source.PremiereDate;
             }
 
-            if (replaceData || !target.ProductionYear.HasValue)
+            if (replaceData || target.ProductionYear is null)
             {
                 target.ProductionYear = source.ProductionYear;
             }
diff --git a/MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs b/MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs
index f9d8883dff..ff14f87923 100644
--- a/MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs
+++ b/MediaBrowser.Providers/MediaInfo/FFProbeVideoInfo.cs
@@ -432,9 +432,9 @@ namespace MediaBrowser.Providers.MediaInfo
                 }
             }
 
-            if (data.ProductionYear.HasValue)
+            if (data.ProductionYear is not null)
             {
-                if (!video.ProductionYear.HasValue || replaceData)
+                if (video.ProductionYear is null || replaceData)
                 {
                     video.ProductionYear = data.ProductionYear;
                 }
@@ -482,7 +482,7 @@ namespace MediaBrowser.Providers.MediaInfo
             }
 
             // If we don't have a ProductionYear try and get it from PremiereDate
-            if (video.PremiereDate.HasValue && !video.ProductionYear.HasValue)
+            if (video.PremiereDate is not null && video.ProductionYear is null)
             {
                 video.ProductionYear = video.PremiereDate.Value.ToLocalTime().Year;
             }
diff --git a/MediaBrowser.XbmcMetadata/Savers/ArtistNfoSaver.cs b/MediaBrowser.XbmcMetadata/Savers/ArtistNfoSaver.cs
index b5ba2d24f2..af2557df78 100644
--- a/MediaBrowser.XbmcMetadata/Savers/ArtistNfoSaver.cs
+++ b/MediaBrowser.XbmcMetadata/Savers/ArtistNfoSaver.cs
@@ -82,7 +82,7 @@ namespace MediaBrowser.XbmcMetadata.Savers
                     writer.WriteElementString("title", album.Name);
                 }
 
-                if (album.ProductionYear.HasValue)
+                if (album.ProductionYear is not null)
                 {
                     writer.WriteElementString("year", album.ProductionYear.Value.ToString(CultureInfo.InvariantCulture));
                 }
diff --git a/MediaBrowser.XbmcMetadata/Savers/BaseNfoSaver.cs b/MediaBrowser.XbmcMetadata/Savers/BaseNfoSaver.cs
index 78907a5e68..5a9bbbef4f 100644
--- a/MediaBrowser.XbmcMetadata/Savers/BaseNfoSaver.cs
+++ b/MediaBrowser.XbmcMetadata/Savers/BaseNfoSaver.cs
@@ -544,7 +544,7 @@ namespace MediaBrowser.XbmcMetadata.Savers
                 writer.WriteElementString("rating", item.CommunityRating.Value.ToString(CultureInfo.InvariantCulture));
             }
 
-            if (item.ProductionYear.HasValue)
+            if (item.ProductionYear is not null)
             {
                 writer.WriteElementString("year", item.ProductionYear.Value.ToString(CultureInfo.InvariantCulture));
             }
diff --git a/src/Jellyfin.LiveTv/Recordings/RecordingsManager.cs b/src/Jellyfin.LiveTv/Recordings/RecordingsManager.cs
index 846f9baf71..62a06370da 100644
--- a/src/Jellyfin.LiveTv/Recordings/RecordingsManager.cs
+++ b/src/Jellyfin.LiveTv/Recordings/RecordingsManager.cs
@@ -497,7 +497,7 @@ public sealed class RecordingsManager : IRecordingsManager, IDisposable
             // trim trailing period from the folder name
             var folderName = _fileSystem.GetValidFilename(timer.Name).Trim().TrimEnd('.').Trim();
 
-            if (metadata is not null && metadata.ProductionYear.HasValue)
+            if (metadata is not null && metadata.ProductionYear is not null)
             {
                 folderName += " (" + metadata.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
             }
@@ -532,7 +532,7 @@ public sealed class RecordingsManager : IRecordingsManager, IDisposable
             }
 
             var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
-            if (timer.ProductionYear.HasValue)
+            if (timer.ProductionYear is not null)
             {
                 folderName += " (" + timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
             }
@@ -550,7 +550,7 @@ public sealed class RecordingsManager : IRecordingsManager, IDisposable
             }
 
             var folderName = _fileSystem.GetValidFilename(timer.Name).Trim();
-            if (timer.ProductionYear.HasValue)
+            if (timer.ProductionYear is not null)
             {
                 folderName += " (" + timer.ProductionYear.Value.ToString(CultureInfo.InvariantCulture) + ")";
             }
diff --git a/src/Jellyfin.LiveTv/Recordings/RecordingsMetadataManager.cs b/src/Jellyfin.LiveTv/Recordings/RecordingsMetadataManager.cs
index 7e68dbb547..e0e5a00fb9 100644
--- a/src/Jellyfin.LiveTv/Recordings/RecordingsMetadataManager.cs
+++ b/src/Jellyfin.LiveTv/Recordings/RecordingsMetadataManager.cs
@@ -290,7 +290,7 @@ public class RecordingsMetadataManager
                     null,
                     DateTime.UtcNow.ToString(DateAddedFormat, CultureInfo.InvariantCulture)).ConfigureAwait(false);
 
-                if (item.ProductionYear.HasValue)
+                if (item.ProductionYear is not null)
                 {
                     await writer.WriteElementStringAsync(null, "year", null, item.ProductionYear.Value.ToString(CultureInfo.InvariantCulture)).ConfigureAwait(false);
                 }
-- 
cgit v1.2.3


From fc0af1050912b94daa6c40455985cb61b12f4486 Mon Sep 17 00:00:00 2001
From: mbastian77 <michael.bastian@visop.de>
Date: Wed, 15 Jul 2026 11:56:54 +0200
Subject: Avoid unnecessary list allocation in CheckForIdlePlayback

---
 Emby.Server.Implementations/Session/SessionManager.cs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Session/SessionManager.cs b/Emby.Server.Implementations/Session/SessionManager.cs
index 828bdd6859..5d62332552 100644
--- a/Emby.Server.Implementations/Session/SessionManager.cs
+++ b/Emby.Server.Implementations/Session/SessionManager.cs
@@ -641,8 +641,7 @@ namespace Emby.Server.Implementations.Session
             if (playingSessions.Count > 0)
             {
                 var idle = playingSessions
-                    .Where(i => (DateTime.UtcNow - i.LastPlaybackCheckIn).TotalMinutes > 5)
-                    .ToList();
+                    .Where(i => (DateTime.UtcNow - i.LastPlaybackCheckIn).TotalMinutes > 5);
 
                 foreach (var session in idle)
                 {
-- 
cgit v1.2.3


From dc300fae53b6b42090341cb517238bbc76479e02 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 23 Jul 2026 13:35:43 +0200
Subject: Allow duplicate LinkedChildren for Playlists

---
 .../Playlists/PlaylistManager.cs                   |   15 +-
 .../Item/ItemPersistenceService.cs                 |  181 +-
 .../Item/LinkedChildrenService.cs                  |    6 +-
 ...250420190000_RemoveDuplicatePlaylistChildren.cs |   61 -
 .../20260113120000_MigrateLinkedChildren.cs        |    3 +-
 .../Entities/LinkedChildEntity.cs                  |    2 +-
 .../ModelConfiguration/LinkedChildConfiguration.cs |    3 +-
 ...1547_AllowDuplicatePlaylistChildren.Designer.cs | 1808 ++++++++++++++++++++
 ...0260723111547_AllowDuplicatePlaylistChildren.cs |   89 +
 .../Migrations/JellyfinDbModelSnapshot.cs          |   12 +-
 10 files changed, 1994 insertions(+), 186 deletions(-)
 delete mode 100644 Jellyfin.Server/Migrations/Routines/20250420190000_RemoveDuplicatePlaylistChildren.cs
 create mode 100644 src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260723111547_AllowDuplicatePlaylistChildren.Designer.cs
 create mode 100644 src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260723111547_AllowDuplicatePlaylistChildren.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Playlists/PlaylistManager.cs b/Emby.Server.Implementations/Playlists/PlaylistManager.cs
index 409414139c..308faed8cc 100644
--- a/Emby.Server.Implementations/Playlists/PlaylistManager.cs
+++ b/Emby.Server.Implementations/Playlists/PlaylistManager.cs
@@ -219,28 +219,15 @@ namespace Emby.Server.Implementations.Playlists
             var playlist = _libraryManager.GetItemById(playlistId) as Playlist
                 ?? throw new ArgumentException("No Playlist exists with Id " + playlistId);
 
-            // Retrieve all the items to be added to the playlist
+            // Retrieve all the items to be added to the playlist.
             var newItems = GetPlaylistItems(newItemIds, user, options)
                 .Where(i => i.SupportsAddingToPlaylist);
 
-            // Filter out duplicate items
-            var existingIds = playlist.LinkedChildren.Select(c => c.ItemId).ToHashSet();
-            newItems = newItems
-                .Where(i => !existingIds.Contains(i.Id))
-                .Distinct();
-
             // Create a list of the new linked children to add to the playlist
             var childrenToAdd = newItems
                 .Select(LinkedChild.Create)
                 .ToList();
 
-            // Log duplicates that have been ignored, if any
-            int numDuplicates = newItemIds.Count - childrenToAdd.Count;
-            if (numDuplicates > 0)
-            {
-                _logger.LogWarning("Ignored adding {DuplicateCount} duplicate items to playlist {PlaylistName}.", numDuplicates, playlist.Name);
-            }
-
             // Do nothing else if there are no items to add to the playlist
             if (childrenToAdd.Count == 0)
             {
diff --git a/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs b/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
index b10f7c527e..9201a031d5 100644
--- a/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
+++ b/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
@@ -428,106 +428,100 @@ public class ItemPersistenceService : IItemPersistenceService
 
         foreach (var item in tuples)
         {
-            if (item.Item is Folder folder)
+            if (item.Item is Folder or Video
+                && allLinkedChildrenByParent.TryGetValue(item.Item.Id, out var existingLinks)
+                && existingLinks.Count > 0)
+            {
+                context.LinkedChildren.RemoveRange(existingLinks);
+            }
+        }
+
+        context.SaveChanges();
+
+        foreach (var item in tuples)
+        {
+            if (item.Item is Folder folder && folder.LinkedChildren.Length > 0)
             {
-                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 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 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 resolvedChildren = new List<(LinkedChild Child, Guid ChildId)>();
+                foreach (var linkedChild in folder.LinkedChildren)
+                {
+                    var childItemId = linkedChild.ItemId;
+                    if (!childItemId.HasValue || childItemId.Value.IsEmpty())
                     {
-                        var childItemId = linkedChild.ItemId;
-                        if (!childItemId.HasValue || childItemId.Value.IsEmpty())
+                        if (!string.IsNullOrEmpty(linkedChild.Path) && pathToIdMap.TryGetValue(linkedChild.Path, out var resolvedId))
                         {
-                            if (!string.IsNullOrEmpty(linkedChild.Path) && pathToIdMap.TryGetValue(linkedChild.Path, out var resolvedId))
-                            {
-                                childItemId = resolvedId;
-                            }
+                            childItemId = resolvedId;
                         }
+                    }
 #pragma warning restore CS0618
 
-                        if (childItemId.HasValue && !childItemId.Value.IsEmpty())
-                        {
-                            resolvedChildren.Add((linkedChild, childItemId.Value));
-                        }
+                    if (childItemId.HasValue && !childItemId.Value.IsEmpty())
+                    {
+                        resolvedChildren.Add((linkedChild, childItemId.Value));
                     }
+                }
 
+                // Playlists may legitimately contain the same item multiple times (e.g. a song repeated
+                // in an .m3u file). Every other container type keeps a single entry per child.
+                var isPlaylist = folder is Playlist;
+                if (!isPlaylist)
+                {
                     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);
-                        }
+                var childIdsToCheck = resolvedChildren.Select(c => c.ChildId).Distinct().ToList();
+                var existingChildIds = childIdsToCheck.Count > 0
+                    ? context.BaseItems
+                        .Where(e => childIdsToCheck.Contains(e.Id))
+                        .Select(e => e.Id)
+                        .ToHashSet()
+                    : [];
 
-                        sortOrder++;
+                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;
                     }
-                }
 
-                if (existingLinkedChildren.Count > 0)
-                {
-                    context.LinkedChildren.RemoveRange(existingLinkedChildren);
+                    context.LinkedChildren.Add(new LinkedChildEntity()
+                    {
+                        ParentId = item.Item.Id,
+                        ChildId = childId,
+                        ChildType = (DbLinkedChildType)linkedChild.Type,
+                        SortOrder = sortOrder
+                    });
+
+                    sortOrder++;
                 }
             }
 
             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)
@@ -577,7 +571,7 @@ public class ItemPersistenceService : IItemPersistenceService
                         .ToHashSet()
                     : [];
 
-                int sortOrder = 0;
+                var sortOrder = 0;
                 foreach (var (childId, childType) in newLinkedChildren)
                 {
                     if (!existingChildIds.Contains(childId))
@@ -590,36 +584,27 @@ public class ItemPersistenceService : IItemPersistenceService
                         continue;
                     }
 
-                    var existingLink = existingLinkedChildren.FirstOrDefault(e => e.ChildId == childId);
-                    if (existingLink is null)
+                    context.LinkedChildren.Add(new LinkedChildEntity
                     {
-                        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);
-                    }
+                        ParentId = video.Id,
+                        ChildId = childId,
+                        ChildType = (DbLinkedChildType)childType,
+                        SortOrder = sortOrder
+                    });
 
                     sortOrder++;
                 }
 
-                if (existingLinkedChildren.Count > 0)
+                // A previously-linked LocalAlternateVersion that is no longer present becomes orphaned;
+                var previousLinkedChildren = allLinkedChildrenByParent.GetValueOrDefault(video.Id);
+                if (previousLinkedChildren is { Count: > 0 })
                 {
-                    var orphanedLocalVersionIds = existingLinkedChildren
-                        .Where(e => e.ChildType == DbLinkedChildType.LocalAlternateVersion)
+                    var newChildIds = newLinkedChildren.Select(c => c.ChildId).ToHashSet();
+                    var orphanedLocalVersionIds = previousLinkedChildren
+                        .Where(e => e.ChildType == DbLinkedChildType.LocalAlternateVersion && !newChildIds.Contains(e.ChildId))
                         .Select(e => e.ChildId)
                         .ToList();
 
-                    context.LinkedChildren.RemoveRange(existingLinkedChildren);
-
                     if (orphanedLocalVersionIds.Count > 0)
                     {
                         var orphanedItems = context.BaseItems
diff --git a/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs b/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
index 5e5ce320a5..5f1d9bf87a 100644
--- a/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
+++ b/Jellyfin.Server.Implementations/Item/LinkedChildrenService.cs
@@ -159,12 +159,16 @@ public class LinkedChildrenService : ILinkedChildrenService
 
         if (existingLink is null)
         {
+            var nextSortOrder = (context.LinkedChildren
+                .Where(lc => lc.ParentId == parentId)
+                .Max(lc => (int?)lc.SortOrder) ?? -1) + 1;
+
             context.LinkedChildren.Add(new Jellyfin.Database.Implementations.Entities.LinkedChildEntity
             {
                 ParentId = parentId,
                 ChildId = childId,
                 ChildType = dbChildType,
-                SortOrder = null
+                SortOrder = nextSortOrder
             });
         }
         else
diff --git a/Jellyfin.Server/Migrations/Routines/20250420190000_RemoveDuplicatePlaylistChildren.cs b/Jellyfin.Server/Migrations/Routines/20250420190000_RemoveDuplicatePlaylistChildren.cs
deleted file mode 100644
index 1545ebdc8e..0000000000
--- a/Jellyfin.Server/Migrations/Routines/20250420190000_RemoveDuplicatePlaylistChildren.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-using System;
-using System.Linq;
-using System.Threading;
-using Jellyfin.Data.Enums;
-using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Library;
-using MediaBrowser.Controller.Playlists;
-
-namespace Jellyfin.Server.Migrations.Routines;
-
-/// <summary>
-/// Remove duplicate playlist entries.
-/// </summary>
-#pragma warning disable CS0618 // Type or member is obsolete
-[JellyfinMigration("2025-04-20T19:00:00", nameof(RemoveDuplicatePlaylistChildren), "96C156A2-7A13-4B3B-A8B8-FB80C94D20C0")]
-internal class RemoveDuplicatePlaylistChildren : IMigrationRoutine
-#pragma warning restore CS0618 // Type or member is obsolete
-{
-    private readonly ILibraryManager _libraryManager;
-    private readonly IPlaylistManager _playlistManager;
-
-    public RemoveDuplicatePlaylistChildren(
-        ILibraryManager libraryManager,
-        IPlaylistManager playlistManager)
-    {
-        _libraryManager = libraryManager;
-        _playlistManager = playlistManager;
-    }
-
-    /// <inheritdoc/>
-    public void Perform()
-    {
-        var playlists = _libraryManager.GetItemList(new InternalItemsQuery
-        {
-            IncludeItemTypes = [BaseItemKind.Playlist]
-        })
-        .Cast<Playlist>()
-        .Where(p => !p.OpenAccess || !p.OwnerUserId.Equals(Guid.Empty))
-        .ToArray();
-
-        if (playlists.Length > 0)
-        {
-            foreach (var playlist in playlists)
-            {
-                var linkedChildren = playlist.LinkedChildren;
-                if (linkedChildren.Length > 0)
-                {
-                    var newLinkedChildren = linkedChildren
-                        .Where(c => c.ItemId is null || c.ItemId.Value.Equals(Guid.Empty))
-                        .Concat(linkedChildren
-                            .Where(c => c.ItemId.HasValue && !c.ItemId.Value.Equals(Guid.Empty))
-                            .DistinctBy(c => c.ItemId))
-                        .ToArray();
-                    playlist.LinkedChildren = newLinkedChildren;
-                    playlist.UpdateToRepositoryAsync(ItemUpdateType.MetadataEdit, CancellationToken.None).GetAwaiter().GetResult();
-                    _playlistManager.SavePlaylistFile(playlist);
-                }
-            }
-        }
-    }
-}
diff --git a/Jellyfin.Server/Migrations/Routines/20260113120000_MigrateLinkedChildren.cs b/Jellyfin.Server/Migrations/Routines/20260113120000_MigrateLinkedChildren.cs
index c433c1d043..d13c6cf700 100644
--- a/Jellyfin.Server/Migrations/Routines/20260113120000_MigrateLinkedChildren.cs
+++ b/Jellyfin.Server/Migrations/Routines/20260113120000_MigrateLinkedChildren.cs
@@ -110,7 +110,6 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
                     continue;
                 }
 
-                var isPlaylist = item.Type == "MediaBrowser.Controller.Playlists.Playlist";
                 var sortOrder = 0;
                 foreach (var childElement in linkedChildrenElement.EnumerateArray())
                 {
@@ -175,7 +174,7 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
                         ParentId = item.Id,
                         ChildId = childId.Value,
                         ChildType = childType,
-                        SortOrder = isPlaylist ? sortOrder : null
+                        SortOrder = sortOrder
                     });
 
                     sortOrder++;
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/LinkedChildEntity.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/LinkedChildEntity.cs
index 7361775711..be315f1b2c 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/LinkedChildEntity.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Entities/LinkedChildEntity.cs
@@ -25,7 +25,7 @@ public class LinkedChildEntity
     /// <summary>
     /// Gets or sets the sort order.
     /// </summary>
-    public int? SortOrder { get; set; }
+    public int SortOrder { get; set; }
 
     /// <summary>
     /// Gets or sets the parent item navigation property.
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/LinkedChildConfiguration.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/LinkedChildConfiguration.cs
index 2abccd41f0..b4013a394f 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/LinkedChildConfiguration.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/ModelConfiguration/LinkedChildConfiguration.cs
@@ -13,8 +13,7 @@ public class LinkedChildConfiguration : IEntityTypeConfiguration<LinkedChildEnti
     public void Configure(EntityTypeBuilder<LinkedChildEntity> builder)
     {
         builder.ToTable("LinkedChildren");
-        builder.HasKey(e => new { e.ParentId, e.ChildId });
-        builder.HasIndex(e => new { e.ParentId, e.SortOrder });
+        builder.HasKey(e => new { e.ParentId, e.SortOrder });
         builder.HasIndex(e => new { e.ParentId, e.ChildType });
         builder.HasIndex(e => new { e.ChildId, e.ChildType });
 
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260723111547_AllowDuplicatePlaylistChildren.Designer.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260723111547_AllowDuplicatePlaylistChildren.Designer.cs
new file mode 100644
index 0000000000..d5b6bd1d51
--- /dev/null
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260723111547_AllowDuplicatePlaylistChildren.Designer.cs
@@ -0,0 +1,1808 @@
+// <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("20260723111547_AllowDuplicatePlaylistChildren")]
+    partial class AllowDuplicatePlaylistChildren
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.10");
+
+            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>("OriginalLanguage")
+                        .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<int>("SortOrder")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<Guid>("ChildId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("ChildType")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("ParentId", "SortOrder");
+
+                    b.HasIndex("ChildId", "ChildType");
+
+                    b.HasIndex("ParentId", "ChildType");
+
+                    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<bool>("IsOriginal")
+                        .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>("NormalizedUsername")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("TEXT");
+
+                    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("NormalizedUsername")
+                        .IsUnique();
+
+                    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/20260723111547_AllowDuplicatePlaylistChildren.cs b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260723111547_AllowDuplicatePlaylistChildren.cs
new file mode 100644
index 0000000000..173213034e
--- /dev/null
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Migrations/20260723111547_AllowDuplicatePlaylistChildren.cs
@@ -0,0 +1,89 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace Jellyfin.Database.Providers.Sqlite.Migrations
+{
+    /// <inheritdoc />
+    public partial class AllowDuplicatePlaylistChildren : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            // Rows that predate the composite (ParentId, SortOrder) primary key stored a null SortOrder
+            // (e.g. BoxSet and Collection children). Assign each such row a stable 0-based position within
+            // its parent so the rows stay unique once SortOrder becomes part of the primary key; otherwise
+            // they would all collapse to the column default (0) and collide during the table rebuild.
+            migrationBuilder.Sql(
+                @"UPDATE ""LinkedChildren""
+                  SET ""SortOrder"" = (
+                      SELECT COUNT(*)
+                      FROM ""LinkedChildren"" AS lc2
+                      WHERE lc2.""ParentId"" = ""LinkedChildren"".""ParentId""
+                        AND lc2.""rowid"" < ""LinkedChildren"".""rowid""
+                  )
+                  WHERE ""SortOrder"" IS NULL;");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_LinkedChildren",
+                table: "LinkedChildren");
+
+            migrationBuilder.DropIndex(
+                name: "IX_LinkedChildren_ParentId_SortOrder",
+                table: "LinkedChildren");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "SortOrder",
+                table: "LinkedChildren",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0,
+                oldClrType: typeof(int),
+                oldType: "INTEGER",
+                oldNullable: true);
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_LinkedChildren",
+                table: "LinkedChildren",
+                columns: new[] { "ParentId", "SortOrder" });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            // The (ParentId, ChildId) primary key cannot represent the same child more than once per
+            // parent. Drop any duplicate entries (keeping the first by SortOrder) that may have been
+            // created while duplicates were allowed, so the old key can be restored. This is lossy by
+            // nature — duplicate playlist entries cannot survive a downgrade.
+            migrationBuilder.Sql(
+                @"DELETE FROM ""LinkedChildren""
+                  WHERE ""rowid"" NOT IN (
+                      SELECT MIN(""rowid"")
+                      FROM ""LinkedChildren""
+                      GROUP BY ""ParentId"", ""ChildId""
+                  );");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_LinkedChildren",
+                table: "LinkedChildren");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "SortOrder",
+                table: "LinkedChildren",
+                type: "INTEGER",
+                nullable: true,
+                oldClrType: typeof(int),
+                oldType: "INTEGER");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_LinkedChildren",
+                table: "LinkedChildren",
+                columns: new[] { "ParentId", "ChildId" });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_LinkedChildren_ParentId_SortOrder",
+                table: "LinkedChildren",
+                columns: new[] { "ParentId", "SortOrder" });
+        }
+    }
+}
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 fd18c035e6..76bd793269 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.12");
+            modelBuilder.HasAnnotation("ProductVersion", "10.0.10");
 
             modelBuilder.Entity("Jellyfin.Database.Implementations.Entities.AccessSchedule", b =>
                 {
@@ -812,23 +812,21 @@ namespace Jellyfin.Server.Implementations.Migrations
                     b.Property<Guid>("ParentId")
                         .HasColumnType("TEXT");
 
+                    b.Property<int>("SortOrder")
+                        .HasColumnType("INTEGER");
+
                     b.Property<Guid>("ChildId")
                         .HasColumnType("TEXT");
 
                     b.Property<int>("ChildType")
                         .HasColumnType("INTEGER");
 
-                    b.Property<int?>("SortOrder")
-                        .HasColumnType("INTEGER");
-
-                    b.HasKey("ParentId", "ChildId");
+                    b.HasKey("ParentId", "SortOrder");
 
                     b.HasIndex("ChildId", "ChildType");
 
                     b.HasIndex("ParentId", "ChildType");
 
-                    b.HasIndex("ParentId", "SortOrder");
-
                     b.ToTable("LinkedChildren", (string)null);
 
                     b.HasAnnotation("Sqlite:UseSqlReturningClause", false);
-- 
cgit v1.2.3


From 9aa79682bab9a18f87b0c13c776a19e3eb357335 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Thu, 23 Jul 2026 11:52:26 +0200
Subject: Reduce correlated subqueries to improve performance

---
 Emby.Server.Implementations/Dto/DtoService.cs      |  25 +++--
 .../Item/BaseItemRepository.ByName.cs              | 103 ++++++++++++++-------
 .../Item/BaseItemRepository.Querying.cs            |  91 +++++++++++++-----
 .../Item/PeopleRepository.cs                       |   8 +-
 .../JellyfinQueryHelperExtensions.cs               |  65 ++++++++-----
 .../Dto/DtoServiceImageInheritanceTests.cs         |  70 +++++++++++++-
 6 files changed, 270 insertions(+), 92 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Dto/DtoService.cs b/Emby.Server.Implementations/Dto/DtoService.cs
index 8cbf42585d..71c3b24907 100644
--- a/Emby.Server.Implementations/Dto/DtoService.cs
+++ b/Emby.Server.Implementations/Dto/DtoService.cs
@@ -1088,7 +1088,7 @@ namespace Emby.Server.Implementations.Dto
                 dto.ParentId = item.DisplayParentId;
             }
 
-            AddInheritedImages(dto, item, options, owner);
+            AddInheritedImages(dto, item, options, owner, artistsBatch);
 
             if (options.ContainsField(ItemFields.Path))
             {
@@ -1519,11 +1519,11 @@ namespace Emby.Server.Implementations.Dto
             }
         }
 
-        private BaseItem? GetImageDisplayParent(BaseItem currentItem, BaseItem originalItem)
+        private BaseItem? GetImageDisplayParent(BaseItem currentItem, BaseItem originalItem, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch)
         {
             if (currentItem is MusicAlbum musicAlbum)
             {
-                var artist = musicAlbum.GetMusicArtist(new DtoOptions(false));
+                var artist = GetBatchedAlbumArtist(musicAlbum, artistsBatch) ?? musicAlbum.GetMusicArtist(new DtoOptions(false));
                 if (artist is not null)
                 {
                     return artist;
@@ -1540,7 +1540,20 @@ namespace Emby.Server.Implementations.Dto
             return parent;
         }
 
-        private void AddInheritedImages(BaseItemDto dto, BaseItem item, DtoOptions options, BaseItem? owner)
+        private static MusicArtist? GetBatchedAlbumArtist(MusicAlbum album, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch)
+        {
+            if (artistsBatch is null)
+            {
+                return null;
+            }
+
+            var name = album.AlbumArtists.Count > 0 ? album.AlbumArtists[0] : null;
+            return !string.IsNullOrEmpty(name) && artistsBatch.TryGetValue(name, out var artists) && artists.Length > 0
+                ? artists[0]
+                : null;
+        }
+
+        private void AddInheritedImages(BaseItemDto dto, BaseItem item, DtoOptions options, BaseItem? owner, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch)
         {
             if (item is UserView { ViewType: CollectionType.playlists } playlistsView
                 && options.GetImageLimit(ImageType.Primary) > 0
@@ -1585,7 +1598,7 @@ namespace Emby.Server.Implementations.Dto
                 || (!(imageTags is not null && imageTags.ContainsKey(ImageType.Thumb)) && thumbLimit > 0)
                 || parent is Series)
             {
-                parent ??= isFirst ? GetImageDisplayParent(item, item) ?? owner : parent;
+                parent ??= isFirst ? GetImageDisplayParent(item, item, artistsBatch) ?? owner : parent;
                 if (parent is null)
                 {
                     break;
@@ -1644,7 +1657,7 @@ namespace Emby.Server.Implementations.Dto
                     break;
                 }
 
-                parent = GetImageDisplayParent(parent, item);
+                parent = GetImageDisplayParent(parent, item, artistsBatch);
             }
         }
 
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs
index 6fe8563bf5..1d34346888 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.ByName.cs
@@ -4,6 +4,7 @@ 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.Model.Dto;
@@ -109,7 +110,6 @@ public sealed partial class BaseItemRepository
                 IsNews = filter.IsNews,
                 IsSeries = filter.IsSeries
             })
-            .Where(e => e.MediaStreams != null)
             .SelectMany(e => e.MediaStreams!)
             .Where(e => e.StreamType == (MediaStreamTypeEntity)mediaStreamType)
             .Select(s => string.IsNullOrEmpty(s.Language) ? "und" : s.Language) // und = undetermined
@@ -168,9 +168,7 @@ public sealed partial class BaseItemRepository
             IsSeries = filter.IsSeries
         });
 
-        // Keep this as an IQueryable sub-select. Materializing to a list would inline one
-        // bound parameter per CleanValue and hit SQLite's variable cap on libraries with
-        // high-cardinality value types (e.g. tens of thousands of artists).
+        // Resolve, then materialize, the set of clean values belonging to items that match the inner filter.
         var matchingCleanValues = context.ItemValuesMap
             .Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))
             .Join(
@@ -178,11 +176,13 @@ public sealed partial class BaseItemRepository
                 ivm => ivm.ItemId,
                 g => g.Id,
                 (ivm, g) => ivm.ItemValue.CleanValue)
-            .Distinct();
+            .Distinct()
+            .ToList();
 
+        // Match CleanName against the resolved clean values.
         var innerQuery = PrepareItemQuery(context, filter)
             .Where(e => e.Type == returnType)
-            .Where(e => matchingCleanValues.Contains(e.CleanName!));
+            .WhereOneOrMany(matchingCleanValues, e => e.CleanName!);
 
         var outerQueryFilter = new InternalItemsQuery(filter.User)
         {
@@ -205,32 +205,42 @@ public sealed partial class BaseItemRepository
             ExcludeItemIds = filter.ExcludeItemIds
         };
 
-        // Collapse rows that share a PresentationUniqueKey (e.g. alternate versions) by picking
-        // the lowest Id per group. For MusicArtist, prefer the entity from a library the user
-        // can actually access,since the same artist can have a folder in multiple libraries.
-        // Keep as an IQueryable sub-select so paging is applied AFTER
-        // ApplyOrder runs the caller's actual sort.
+        // Collapse rows that share a PresentationUniqueKey (e.g. alternate versions) into one
+        // representative id per group, then materialize the representative ids once.
         var masterQuery = TranslateQuery(innerQuery, context, outerQueryFilter);
         var isMusicArtist = returnType == _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicArtist];
-        var representativeIds = isMusicArtist
-            ? masterQuery
+        List<Guid> representativeIds;
+        if (isMusicArtist)
+        {
+            // For MusicArtist, prefer the entity from a library the user can actually access.
+            // Materilaize to prevent correlated per-group first-row queries which hurt performance.
+            var topParentIds = filter.TopParentIds;
+            representativeIds = masterQuery
+                .Select(e => new { e.Id, e.PresentationUniqueKey, e.TopParentId })
+                .AsEnumerable()
                 .GroupBy(e => e.PresentationUniqueKey)
                 .Select(g => g
-                    .OrderBy(e => filter.TopParentIds.Contains(e.TopParentId ?? Guid.Empty) ? 0 : 1)
+                    .OrderBy(e => topParentIds.Contains(e.TopParentId ?? Guid.Empty) ? 0 : 1)
                     .ThenBy(e => e.Id)
                     .First().Id)
-            : masterQuery
+                .ToList();
+        }
+        else
+        {
+            representativeIds = masterQuery
                 .GroupBy(e => e.PresentationUniqueKey)
-                .Select(g => g.Min(e => e.Id));
+                .Select(g => g.Min(e => e.Id))
+                .ToList();
+        }
 
         var result = new QueryResult<(BaseItemDto, ItemCounts?)>();
         if (filter.EnableTotalRecordCount)
         {
-            result.TotalRecordCount = representativeIds.Count();
+            result.TotalRecordCount = representativeIds.Count;
         }
 
         var query = ApplyNavigations(
-                context.BaseItems.AsNoTracking().AsSingleQuery().Where(e => representativeIds.Contains(e.Id)),
+                context.BaseItems.AsNoTracking().AsSingleQuery().WhereOneOrMany(representativeIds, e => e.Id),
                 filter);
 
         query = ApplyOrder(query, filter, context);
@@ -311,8 +321,8 @@ public sealed partial class BaseItemRepository
         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
-        return context.ItemValuesMap
+        // Instead, start from ItemValueMaps and join with BaseItems.
+        var rawCounts = context.ItemValuesMap
             .Where(ivm => itemValueTypes.Contains(ivm.ItemValue.Type))
             .Where(ivm => itemIds.Contains(ivm.ItemId))
             .Join(
@@ -322,18 +332,47 @@ public sealed partial class BaseItemRepository
                 (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
+            .AsEnumerable();
+
+        var countsByCleanName = new Dictionary<string, ItemCounts>();
+        foreach (var group in rawCounts.GroupBy(x => x.CleanName))
+        {
+            var counts = new ItemCounts();
+            foreach (var row in group)
+            {
+                if (row.Type == seriesTypeName)
                 {
-                    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),
-                });
+                    counts.SeriesCount += row.Count;
+                }
+                else if (row.Type == episodeTypeName)
+                {
+                    counts.EpisodeCount += row.Count;
+                }
+                else if (row.Type == movieTypeName)
+                {
+                    counts.MovieCount += row.Count;
+                }
+                else if (row.Type == musicAlbumTypeName)
+                {
+                    counts.AlbumCount += row.Count;
+                }
+                else if (row.Type == musicArtistTypeName)
+                {
+                    counts.ArtistCount += row.Count;
+                }
+                else if (row.Type == audioTypeName)
+                {
+                    counts.SongCount += row.Count;
+                }
+                else if (row.Type == trailerTypeName)
+                {
+                    counts.TrailerCount += row.Count;
+                }
+            }
+
+            countsByCleanName[group.Key] = counts;
+        }
+
+        return countsByCleanName;
     }
 }
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs
index dc16c3b1b3..00af0bcbeb 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.Querying.cs
@@ -126,38 +126,60 @@ public sealed partial class BaseItemRepository
 
         if (collectionType is CollectionType.movies)
         {
-            // Group by PresentationUniqueKey, pick the newest item per group.
-            var topGroupItems = baseQuery
+            // Pick, per PresentationUniqueKey, the newest item; return the newest `limit` of those.
+            // Build up until limit by streaming through results and deduplicating on the fly.
+            var orderedIds = baseQuery
                 .Where(e => e.PresentationUniqueKey != null)
-                .GroupBy(e => e.PresentationUniqueKey)
-                .Select(g => new
-                {
-                    MaxDate = g.Max(e => e.DateCreated),
-                    FirstId = g.OrderByDescending(e => e.DateCreated).ThenByDescending(e => e.Id).Select(e => e.Id).First()
-                })
-                .OrderByDescending(g => g.MaxDate);
+                .OrderByDescending(e => e.DateCreated)
+                .ThenByDescending(e => e.Id)
+                .Select(e => new { e.Id, e.PresentationUniqueKey });
 
-            var firstIdsQuery = filter.Limit.HasValue
-                ? topGroupItems.Take(filter.Limit.Value).Select(g => g.FirstId)
-                : topGroupItems.Select(g => g.FirstId);
+            var seenKeys = new HashSet<string>();
+            var firstIds = new List<Guid>(limit ?? 0);
+            foreach (var row in orderedIds.AsEnumerable())
+            {
+                if (seenKeys.Add(row.PresentationUniqueKey!))
+                {
+                    firstIds.Add(row.Id);
+                    if (limit.HasValue && firstIds.Count >= limit.Value)
+                    {
+                        break;
+                    }
+                }
+            }
 
-            return LoadLatestByIds(context, firstIdsQuery, filter);
+            return LoadLatestByIds(context, firstIds, filter);
         }
 
-        // Albums whose Id is the parent of any track matching the user's filter.
-        var albumIdsWithMatchingTrack = context.AncestorIds
-            .Join(baseQuery, ai => ai.ItemId, t => t.Id, (ai, _) => ai.ParentItemId);
-
         var musicAlbumTypeName = _itemTypeLookup.BaseItemKindNames[BaseItemKind.MusicAlbum]!;
-        var topAlbumsQuery = context.BaseItems.AsNoTracking()
-            .Where(album => album.Type == musicAlbumTypeName)
-            .Where(album => albumIdsWithMatchingTrack.Contains(album.Id))
+        IQueryable<BaseItemEntity> topAlbumsQuery;
+
+        // When the query is scoped to whole libraries, read the newest albums directly by their own TopParentId.
+        if (filter.TopParentIds.Length > 0)
+        {
+            topAlbumsQuery = context.BaseItems.AsNoTracking()
+                .Where(album => album.Type == musicAlbumTypeName
+                    && !album.IsVirtualItem
+                    && album.TopParentId.HasValue)
+                .WhereOneOrMany(filter.TopParentIds, album => album.TopParentId!.Value);
+        }
+        else
+        {
+            // Fallback (e.g. AncestorIds-scoped callers): albums that are the parent of a matching track.
+            var albumIdsWithMatchingTrack = context.AncestorIds
+                .Join(baseQuery, ai => ai.ItemId, t => t.Id, (ai, _) => ai.ParentItemId);
+            topAlbumsQuery = context.BaseItems.AsNoTracking()
+                .Where(album => album.Type == musicAlbumTypeName)
+                .Where(album => albumIdsWithMatchingTrack.Contains(album.Id));
+        }
+
+        var orderedAlbums = topAlbumsQuery
             .OrderByDescending(album => album.DateCreated)
             .ThenByDescending(album => album.Id);
 
-        var albumIdsQuery = filter.Limit.HasValue
-            ? topAlbumsQuery.Take(filter.Limit.Value).Select(a => a.Id)
-            : topAlbumsQuery.Select(a => a.Id);
+        var albumIdsQuery = limit.HasValue
+            ? orderedAlbums.Take(limit.Value).Select(a => a.Id)
+            : orderedAlbums.Select(a => a.Id);
 
         return LoadLatestByIds(context, albumIdsQuery, filter);
     }
@@ -181,6 +203,29 @@ public sealed partial class BaseItemRepository
             .ToArray()!;
     }
 
+    private IReadOnlyList<BaseItemDto> LoadLatestByIds(
+        JellyfinDbContext context,
+        List<Guid> ids,
+        InternalItemsQuery filter)
+    {
+        if (ids.Count == 0)
+        {
+            return [];
+        }
+
+        var itemsQuery = ApplyNavigations(
+            context.BaseItems.AsNoTracking().WhereOneOrMany(ids, e => e.Id),
+            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>
diff --git a/Jellyfin.Server.Implementations/Item/PeopleRepository.cs b/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
index eb87b525fe..9611c5c13a 100644
--- a/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/PeopleRepository.cs
@@ -79,7 +79,11 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
     public IReadOnlyList<string> GetPeopleNames(InternalPeopleQuery filter)
     {
         using var context = _dbProvider.CreateDbContext();
-        var dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter).Select(e => e.Name).Distinct();
+
+        IQueryable<string> dbQuery = TranslateQuery(context.Peoples.AsNoTracking(), context, filter)
+            .Select(e => e.Name)
+            .Distinct()
+            .OrderBy(e => e);
 
         if (filter.StartIndex.HasValue && filter.StartIndex > 0)
         {
@@ -88,7 +92,7 @@ public class PeopleRepository(IDbContextFactory<JellyfinDbContext> dbProvider, I
 
         if (filter.Limit > 0)
         {
-            dbQuery = dbQuery.OrderBy(e => e).Take(filter.Limit);
+            dbQuery = dbQuery.Take(filter.Limit);
         }
 
         return dbQuery.ToArray();
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/JellyfinQueryHelperExtensions.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/JellyfinQueryHelperExtensions.cs
index 1af7460540..fec37ce723 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/JellyfinQueryHelperExtensions.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/JellyfinQueryHelperExtensions.cs
@@ -70,15 +70,24 @@ public static class JellyfinQueryHelperExtensions
         bool invert = false)
     {
         var itemFilter = OneOrManyExpressionBuilder<BaseItemEntity, Guid>(referenceIds, f => f.Id);
-        var typeFilter = OneOrManyExpressionBuilder<ItemValue, ItemValueType>(itemValueTypes, iv => iv.Type);
-
-        return baseQuery.Where(item =>
-            context.ItemValues
-                .Where(typeFilter)
-                .Join(context.ItemValuesMap, e => e.ItemValueId, e => e.ItemValueId, (itemVal, map) => new { itemVal, map })
-                .Any(val =>
-                    context.BaseItems.Where(itemFilter).Any(e => e.CleanName == val.itemVal.CleanValue)
-                    && val.map.ItemId == item.Id) == EF.Constant(!invert));
+        var typeFilter = OneOrManyExpressionBuilder<ItemValueMap, ItemValueType>(itemValueTypes, m => m.ItemValue.Type);
+
+        // Flat sub-selects + Contains instead of a nested correlated .Any(...Any(...)).
+        var referencedCleanValues = context.BaseItems
+            .Where(itemFilter)
+            .Select(e => e.CleanName);
+
+        var matchingItemIds = context.ItemValuesMap
+            .Where(typeFilter)
+            .Where(m => referencedCleanValues.Contains(m.ItemValue.CleanValue))
+            .Select(m => m.ItemId);
+
+        if (invert)
+        {
+            return baseQuery.Where(e => !matchingItemIds.Contains(e.Id));
+        }
+
+        return baseQuery.Where(e => matchingItemIds.Contains(e.Id));
     }
 
     /// <summary>
@@ -102,13 +111,21 @@ public static class JellyfinQueryHelperExtensions
 
         var itemFilter = OneOrManyExpressionBuilder<BaseItemEntity, Guid>(referenceIds, f => f.Id);
 
-        return item =>
-          context.ItemValues
-              .Join(context.ItemValuesMap, e => e.ItemValueId, e => e.ItemValueId, (item, map) => new { item, map })
-              .Any(val =>
-                  val.item.Type == itemValueType
-                  && context.BaseItems.Where(itemFilter).Any(e => e.CleanName == val.item.CleanValue)
-                  && val.map.ItemId == item.Id) == EF.Constant(!invert);
+        // Flat sub-selects + Contains instead of a nested correlated .Any(...Any(...)).
+        var referencedCleanValues = context.BaseItems
+            .Where(itemFilter)
+            .Select(e => e.CleanName);
+
+        var matchingItemIds = context.ItemValuesMap
+            .Where(m => m.ItemValue.Type == itemValueType && referencedCleanValues.Contains(m.ItemValue.CleanValue))
+            .Select(m => m.ItemId);
+
+        if (invert)
+        {
+            return item => !matchingItemIds.Contains(item.Id);
+        }
+
+        return item => matchingItemIds.Contains(item.Id);
     }
 
     /// <summary>
@@ -224,14 +241,14 @@ public static class JellyfinQueryHelperExtensions
 
         var containsMethodInfo = _containsQueryCache.GetOrAdd(typeof(TProperty), static (key) => _containsMethodGenericCache.MakeGenericMethod(key));
 
-        // Threshold picked from microbenchmarks on SQLite: inline IN(const,...) beats a
-        // parameterized array lookup by ~5-10% up to ~32 elements.
-        if (oneOf.Count <= 32)
-        {
-            return Expression.Lambda<Func<TEntity, bool>>(Expression.Call(null, containsMethodInfo, Expression.Constant(oneOf), property.Body), parameter);
-        }
-
-        return Expression.Lambda<Func<TEntity, bool>>(Expression.Call(null, containsMethodInfo, Expression.Call(null, _efParameterInstruction.MakeGenericMethod(oneOf.GetType()), Expression.Constant(oneOf)), property.Body), parameter);
+        // Always wrap the collection in EF.Parameter so EF Core caches a single compiled plan and reuses it across calls.
+        return Expression.Lambda<Func<TEntity, bool>>(
+            Expression.Call(
+                null,
+                containsMethodInfo,
+                Expression.Call(null, _efParameterInstruction.MakeGenericMethod(oneOf.GetType()), Expression.Constant(oneOf)),
+                property.Body),
+            parameter);
     }
 
     internal static class ParameterReplacer
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
index 96625ae670..6b6240e116 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Emby.Server.Implementations.Dto;
 using Emby.Server.Implementations.Playlists;
 using Jellyfin.Data.Enums;
@@ -7,9 +8,9 @@ using MediaBrowser.Controller.Chapters;
 using MediaBrowser.Controller.Drawing;
 using MediaBrowser.Controller.Dto;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
-using MediaBrowser.Controller.MediaEncoding;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Trickplay;
 using MediaBrowser.Model.Entities;
@@ -99,9 +100,72 @@ public class DtoServiceImageInheritanceTests
         Assert.Equal("/images/generated.png", dto.ImageTags[ImageType.Primary]);
     }
 
+    [Fact]
+    public void GetBaseItemDtos_MusicAlbums_ResolveInheritedThumbFromArtistBatch_WithoutPerAlbumLookup()
+    {
+        var artist = new MusicArtist
+        {
+            Id = Guid.NewGuid(),
+            Name = "Some Artist",
+            ImageInfos =
+            [
+                new ItemImageInfo
+                {
+                    Type = ImageType.Thumb,
+                    Path = "/images/artist-thumb.jpg",
+                    DateModified = new DateTime(2026, 1, 1, 0, 0, 0, DateTimeKind.Utc)
+                }
+            ]
+        };
+
+        static MusicAlbum MakeAlbum() => new MusicAlbum
+        {
+            Id = Guid.NewGuid(),
+            Name = "Album",
+            AlbumArtists = ["Some Artist"],
+            ImageInfos = []
+        };
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // DtoService resolves every album-artist name in ONE batch (GetArtists). The album's inherited
+        // Thumb/Backdrop images must come from that batch, not a per-album GetArtist/GetItemList lookup
+        // (the N+1). GetArtist is intentionally left unset: a regression to the per-album path would
+        // resolve no artist and fail the assertions below.
+        libraryManager
+            .Setup(x => x.GetArtists(It.IsAny<IReadOnlyList<string>>()))
+            .Returns(new Dictionary<string, MusicArtist[]>(StringComparer.OrdinalIgnoreCase)
+            {
+                ["Some Artist"] = [artist]
+            });
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var dtos = dtoService.GetBaseItemDtos([MakeAlbum(), MakeAlbum()], new DtoOptions(false));
+
+        Assert.Equal(2, dtos.Count);
+        foreach (var dto in dtos)
+        {
+            Assert.Equal(artist.Id, dto.ParentThumbItemId);
+            Assert.Equal("/images/artist-thumb.jpg", dto.ParentThumbImageTag);
+        }
+
+        // The artist lookup is batched once for the whole set, never once per album.
+        libraryManager.Verify(x => x.GetArtists(It.IsAny<IReadOnlyList<string>>()), Times.Once);
+        libraryManager.Verify(x => x.GetArtist(It.IsAny<string>(), It.IsAny<DtoOptions>()), Times.Never);
+    }
+
     private static DtoService BuildDtoService(BaseItem displayParent)
     {
         var libraryManager = new Mock<ILibraryManager>();
+        libraryManager
+            .Setup(x => x.GetItemById(displayParent.Id))
+            .Returns(displayParent);
+        return BuildDtoService(libraryManager);
+    }
+
+    private static DtoService BuildDtoService(Mock<ILibraryManager> libraryManager)
+    {
         var userDataManager = new Mock<IUserDataManager>();
         var imageProcessor = new Mock<IImageProcessor>();
         var providerManager = new Mock<IProviderManager>();
@@ -113,10 +177,6 @@ public class DtoServiceImageInheritanceTests
         var chapterManager = new Mock<IChapterManager>();
         var logger = new Mock<Microsoft.Extensions.Logging.ILogger<DtoService>>();
 
-        libraryManager
-            .Setup(x => x.GetItemById(displayParent.Id))
-            .Returns(displayParent);
-
         imageProcessor
             .Setup(x => x.GetImageCacheTag(It.IsAny<BaseItem>(), It.IsAny<ItemImageInfo>()))
             .Returns<BaseItem, ItemImageInfo>((_, image) => image.Path);
-- 
cgit v1.2.3


From 8b70582561754d22fababede84316beead46d3a9 Mon Sep 17 00:00:00 2001
From: Paolo Antinori <pantinor@redhat.com>
Date: Sat, 25 Jul 2026 12:50:32 +0200
Subject: Remove added comments (#17395 review)

---
 Emby.Server.Implementations/Library/LibraryManager.cs        |  3 ---
 .../Library/LibraryManagerSortTests.cs                       | 12 ------------
 2 files changed, 15 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 8d67f0c6c7..1c2d314341 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -2315,9 +2315,6 @@ namespace Emby.Server.Implementations.Library
         {
             var comparer = Comparers.FirstOrDefault(c => name == c.Type);
 
-            // User-dependent comparers (IUserBaseItemComparer) need a User. With no user
-            // (anonymous/API-key /Items requests), a user-dependent sort key is a caller contract
-            // violation — throw rather than silently falling back to a different key.
             if (comparer is IUserBaseItemComparer)
             {
                 if (user is null)
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerSortTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerSortTests.cs
index 9cec9d6736..65ec41291d 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerSortTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/LibraryManagerSortTests.cs
@@ -36,8 +36,6 @@ public class LibraryManagerSortTests
             new Audio { Name = "Alpha", SortName = "Alpha", Id = Guid.NewGuid() },
         };
 
-        // A user-dependent sort key with no user is a caller contract violation — throw,
-        // don't silently fall back to a different key (review feedback on #17395).
         Assert.Throws<ArgumentException>(() => libraryManager.Sort(
             items,
             user: null,
@@ -47,16 +45,9 @@ public class LibraryManagerSortTests
     [Fact]
     public void Sort_DateLastContentAdded_NullUser_OrdersByDateNotSortName()
     {
-        // DateLastMediaAddedComparer does not use User (its GetDate is static), so it must NOT be
-        // treated as a user-dependent comparer: with no user it should still sort by date, not fall
-        // back to SortName.
         var libraryManager = CreateLibraryManager(
             new IBaseItemComparer[] { new DateLastMediaAddedComparer(), new SortNameComparer() });
 
-        // Names are chosen so date-descending and SortName-descending DISAGREE: Alpha is newest
-        // (date-desc rank 1), but Zulu sorts last alphabetically (SortName-desc rank 1). If the
-        // comparer were still tagged IUserBaseItemComparer, the null-user SortName fallback would
-        // return [Zulu, Mike, Alpha] and this assertion would fail.
         BaseItem[] items =
         {
             MakeFolder("Alpha", new DateTime(2026, 1, 1)),
@@ -69,7 +60,6 @@ public class LibraryManagerSortTests
             user: null,
             new[] { (ItemSortBy.DateLastContentAdded, SortOrder.Descending) }).ToArray();
 
-        // Descending by date => newest first: Alpha, Mike, Zulu. (SortName-desc would be Zulu, Mike, Alpha.)
         Assert.Equal(new[] { "Alpha", "Mike", "Zulu" }, sorted.Select(i => i.Name));
     }
 
@@ -82,8 +72,6 @@ public class LibraryManagerSortTests
         fixture.Register(() => new NamingOptions());
         var configMock = fixture.Freeze<Mock<IServerConfigurationManager>>();
         configMock.Setup(c => c.ApplicationPaths.ProgramDataPath).Returns("/data");
-        // BaseItem.SortName/CreateSortName dereference this static; set it so SortName-fallback
-        // paths don't NRE in-process (mirrors AudioResolverTests in the sibling test project).
         BaseItem.ConfigurationManager ??= configMock.Object;
         var itemRepository = fixture.Freeze<Mock<IItemRepository>>();
         itemRepository.Setup(i => i.RetrieveItem(It.IsAny<Guid>())).Returns<BaseItem>(null);
-- 
cgit v1.2.3


From c606102f6d141479737f0f1e5e4677f0db01784b Mon Sep 17 00:00:00 2001
From: Suyash Mittal <suyash8514@gmail.com>
Date: Sat, 25 Jul 2026 07:33:59 -0400
Subject: Translated using Weblate (Hindi) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/hi/

---
 Emby.Server.Implementations/Localization/Core/hi.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/hi.json b/Emby.Server.Implementations/Localization/Core/hi.json
index e98a5fbac1..5fbf61c627 100644
--- a/Emby.Server.Implementations/Localization/Core/hi.json
+++ b/Emby.Server.Implementations/Localization/Core/hi.json
@@ -105,5 +105,6 @@
     "TaskExtractMediaSegmentsDescription": "मीडियासेगमेंट सक्षम प्लगइन्स से मीडिया सेगमेंट निकालता है या प्राप्त करता है।",
     "TaskMoveTrickplayImages": "ट्रिकप्ले छवि स्थान माइग्रेट करें",
     "TaskMoveTrickplayImagesDescription": "लाइब्रेरी सेटिंग्स के अनुसार मौजूदा ट्रिकप्ले फ़ाइलों को स्थानांतरित करता है।",
-    "CleanupUserDataTask": "यूज़र डेटा सफाई कार्य"
+    "CleanupUserDataTask": "यूज़र डेटा सफाई कार्य",
+    "Original": "असली"
 }
-- 
cgit v1.2.3


From b85c9186ef1f4f83308f65f9066d160ddb5ab689 Mon Sep 17 00:00:00 2001
From: krvi <27792771+krvi@users.noreply.github.com>
Date: Fri, 24 Jul 2026 17:17:22 -0400
Subject: Translated using Weblate (Faroese) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/fo/

---
 Emby.Server.Implementations/Localization/Core/fo.json | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/fo.json b/Emby.Server.Implementations/Localization/Core/fo.json
index 8605a752db..e079ada064 100644
--- a/Emby.Server.Implementations/Localization/Core/fo.json
+++ b/Emby.Server.Implementations/Localization/Core/fo.json
@@ -1,5 +1,5 @@
 {
-    "Artists": "Listafólk",
+    "Artists": "Tónlistafólk",
     "Collections": "Søvn",
     "Default": "Forsett",
     "External": "Ytri",
@@ -29,9 +29,9 @@
     "NotificationOptionPluginUpdateInstalled": "Ískoytisforrit dagført",
     "NotificationOptionUserLockedOut": "Brúkari útihýstur",
     "Photos": "Ljósmyndir",
-    "PluginInstalledWithName": "{0} var innlagt",
-    "PluginUninstalledWithName": "{0} var strikað",
-    "PluginUpdatedWithName": "{0} varð dagført",
+    "PluginInstalledWithName": "{0} innlagt",
+    "PluginUninstalledWithName": "{0} strikað",
+    "PluginUpdatedWithName": "{0} dagført",
     "Shows": "Røðir",
     "SubtitleDownloadFailureFromForItem": "Miseydnaðist at niðurtakað undirtekstir til {1} frá {0}",
     "TvShows": "Sjónvarpsrøðir",
@@ -48,5 +48,7 @@
     "TaskDownloadMissingLyricsDescription": "Niðurtekur sangtekstir",
     "Movies": "Filmar",
     "MixedContent": "Blandað innihald",
-    "Music": "Tónleikur"
+    "Music": "Tónleikur",
+    "UserStartedPlayingItemWithValues": "{0} spælur {1} á {2}",
+    "HeaderContinueWatching": "Hald áfram at hyggja"
 }
-- 
cgit v1.2.3


From b04614e18d2aeed8d3d3de920c381c6bd5b97bdb Mon Sep 17 00:00:00 2001
From: Shed Shedson <hjorturthorgeirs+hmp1devq@gmail.com>
Date: Sat, 25 Jul 2026 08:56:29 -0400
Subject: Translated using Weblate (Icelandic) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/is/

---
 Emby.Server.Implementations/Localization/Core/is.json | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/is.json b/Emby.Server.Implementations/Localization/Core/is.json
index 825ad3084e..b889a073a2 100644
--- a/Emby.Server.Implementations/Localization/Core/is.json
+++ b/Emby.Server.Implementations/Localization/Core/is.json
@@ -62,7 +62,7 @@
     "UserDownloadingItemWithValues": "{0} hleður niður {1}",
     "SubtitleDownloadFailureFromForItem": "Tókst ekki að hala niður skjátextum frá {0} til {1}",
     "Shows": "Þættir",
-    "TaskRefreshChannelsDescription": "Endurhlaða upplýsingum netrása.",
+    "TaskRefreshChannelsDescription": "Endurhleður upplýsingum netrása.",
     "TaskRefreshChannels": "Endurhlaða Rásir",
     "TaskCleanTranscodeDescription": "Eyða umkóðuðum skrám sem eru meira en einum degi eldri.",
     "TaskCleanTranscode": "Hreinsa Umkóðunarmöppu",
@@ -80,7 +80,7 @@
     "TasksMaintenanceCategory": "Viðhald",
     "Default": "Sjálfgefið",
     "TaskCleanActivityLog": "Hreinsa athafnaskrá",
-    "TaskRefreshPeople": "Endurnýja fólk",
+    "TaskRefreshPeople": "Endurnýja upplýsingar um fólk",
     "TaskDownloadMissingSubtitles": "Sækja texta sem vantar",
     "TaskOptimizeDatabase": "Fínstilla gagnagrunn",
     "Undefined": "Óskilgreint",
@@ -95,8 +95,8 @@
     "TaskCleanActivityLogDescription": "Eyðir virkniskráningarfærslum sem hafa náð settum hámarksaldri.",
     "Forced": "Þvingað",
     "External": "Útvær",
-    "TaskRefreshTrickplayImagesDescription": "Býr til hraðspilunarmyndir fyrir myndbönd í virkum söfnum.",
-    "TaskRefreshTrickplayImages": "Búa til hraðspilunarmyndir",
+    "TaskRefreshTrickplayImagesDescription": "Býr til hraðspilunarmyndir (Trickplay) fyrir myndbönd í virkum söfnum.",
+    "TaskRefreshTrickplayImages": "Búa til hraðspilunarmyndir (Trickplay)",
     "TaskAudioNormalization": "Hljóðstöðlun",
     "TaskAudioNormalizationDescription": "Leitar að hljóðstöðlunargögnum í skrám.",
     "TaskDownloadMissingLyricsDescription": "Sækja söngtexta fyrir lög",
-- 
cgit v1.2.3


From e565073fd59aa3c372d3a1c061ff70f839b43602 Mon Sep 17 00:00:00 2001
From: krvi <27792771+krvi@users.noreply.github.com>
Date: Mon, 27 Jul 2026 20:51:31 -0400
Subject: Translated using Weblate (Faroese) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/fo/

---
 Emby.Server.Implementations/Localization/Core/fo.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/fo.json b/Emby.Server.Implementations/Localization/Core/fo.json
index e079ada064..d2bba38cb7 100644
--- a/Emby.Server.Implementations/Localization/Core/fo.json
+++ b/Emby.Server.Implementations/Localization/Core/fo.json
@@ -50,5 +50,6 @@
     "MixedContent": "Blandað innihald",
     "Music": "Tónleikur",
     "UserStartedPlayingItemWithValues": "{0} spælur {1} á {2}",
-    "HeaderContinueWatching": "Hald áfram at hyggja"
+    "HeaderContinueWatching": "Hald áfram at hyggja",
+    "MusicVideos": "Sjónbandaløg"
 }
-- 
cgit v1.2.3


From 5b550517b2ca64fee0d060f537901a2bc6604a64 Mon Sep 17 00:00:00 2001
From: David Wagener <david.wagener@pm.me>
Date: Mon, 27 Jul 2026 19:10:03 -0400
Subject: Translated using Weblate (Luxembourgish) Translation:
 Jellyfin/Jellyfin Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/lb/

---
 Emby.Server.Implementations/Localization/Core/lb.json | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/lb.json b/Emby.Server.Implementations/Localization/Core/lb.json
index e94709b083..f3290c3647 100644
--- a/Emby.Server.Implementations/Localization/Core/lb.json
+++ b/Emby.Server.Implementations/Localization/Core/lb.json
@@ -104,5 +104,8 @@
     "TaskKeyframeExtractorDescription": "Extrahéiert Schlësselbiller aus Videodateien, fir méi präzis HLS-Playlisten ze erstellen. Dës Aufgab kann eng längere Zäit daueren.",
     "TaskRefreshChannelsDescription": "Aktualiséiert Informatiounen iwwer Internetkanäl.",
     "TaskExtractMediaSegmentsDescription": "Extrahéiert oder kritt Mediesegmenter aus Plugins, déi MediaSegment ënnerstëtzen.",
-    "TaskOptimizeDatabaseDescription": "Kompriméiert d’Datebank a schneit de fräie Speicherplatz zou. Dës Aufgab no engem Bibliothéik-Scan oder anere Ännerungen, déi Datebankmodifikatioune mat sech bréngen, auszeféieren, kann d’Performance verbesseren."
+    "TaskOptimizeDatabaseDescription": "Kompriméiert d’Datebank a schneit de fräie Speicherplatz zou. Dës Aufgab no engem Bibliothéik-Scan oder anere Ännerungen, déi Datebankmodifikatioune mat sech bréngen, auszeféieren, kann d’Performance verbesseren.",
+    "LyricDownloadFailureFromForItem": "Feeler beim Download vun de Songtexter vun {0} fir {1}",
+    "Original": "Original",
+    "CleanupUserDataTask": "Aufgab fir Berengege vu Benotzerdaten"
 }
-- 
cgit v1.2.3


From c435f63d090e0d88ef832b9fc3b71e8e452b3b6b Mon Sep 17 00:00:00 2001
From: Natawan Jongnetiwisit <TKGAME11@outlook.com>
Date: Tue, 28 Jul 2026 06:23:24 -0400
Subject: Translated using Weblate (Thai) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/th/

---
 Emby.Server.Implementations/Localization/Core/th.json | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/th.json b/Emby.Server.Implementations/Localization/Core/th.json
index 89c2c26748..716e3ae55d 100644
--- a/Emby.Server.Implementations/Localization/Core/th.json
+++ b/Emby.Server.Implementations/Localization/Core/th.json
@@ -106,5 +106,7 @@
     "TaskExtractMediaSegmentsDescription": "แยกหรือดึงส่วนของสื่อจากปลั๊กอินที่เปิดใช้งาน MediaSegment",
     "TaskMoveTrickplayImages": "ย้ายตำแหน่งเก็บภาพตัวอย่าง Trickplay",
     "CleanupUserDataTask": "ส่วนงานล้างข้อมูลผู้ใช้",
-    "CleanupUserDataTaskDescription": "ล้างข้อมูลผู้ใช้ทั้งหมด (สถานะการรับชม สถานะรายการโปรด ฯลฯ) จากสื่อที่ไม่ได้ใช้งานแล้วอย่างน้อย 90 วัน"
+    "CleanupUserDataTaskDescription": "ล้างข้อมูลผู้ใช้ทั้งหมด (สถานะการรับชม สถานะรายการโปรด ฯลฯ) จากสื่อที่ไม่ได้ใช้งานแล้วอย่างน้อย 90 วัน",
+    "LyricDownloadFailureFromForItem": "ไม่สามารถดาวน์โหลดเนื้อเพลงจาก {0} สำหรับ {1}",
+    "Original": "ต้นฉบับ"
 }
-- 
cgit v1.2.3


From 7215950bd4ff42fa8b48f99cf3d09380586500da Mon Sep 17 00:00:00 2001
From: David Wagener <david.wagener@pm.me>
Date: Tue, 28 Jul 2026 07:59:19 -0400
Subject: Translated using Weblate (Luxembourgish) Translation:
 Jellyfin/Jellyfin Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/lb/

---
 Emby.Server.Implementations/Localization/Core/lb.json | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/lb.json b/Emby.Server.Implementations/Localization/Core/lb.json
index f3290c3647..917f26a49c 100644
--- a/Emby.Server.Implementations/Localization/Core/lb.json
+++ b/Emby.Server.Implementations/Localization/Core/lb.json
@@ -107,5 +107,6 @@
     "TaskOptimizeDatabaseDescription": "Kompriméiert d’Datebank a schneit de fräie Speicherplatz zou. Dës Aufgab no engem Bibliothéik-Scan oder anere Ännerungen, déi Datebankmodifikatioune mat sech bréngen, auszeféieren, kann d’Performance verbesseren.",
     "LyricDownloadFailureFromForItem": "Feeler beim Download vun de Songtexter vun {0} fir {1}",
     "Original": "Original",
-    "CleanupUserDataTask": "Aufgab fir Berengege vu Benotzerdaten"
+    "CleanupUserDataTask": "Aufgab fir Berengege vu Benotzerdaten",
+    "CleanupUserDataTaskDescription": "Läscht all Benotzerdaten (Ofspillstatus, Favoritestatus, asw.) vu Medien, déi zënter mindestens 90 Deeg net méi besteeënd sinn."
 }
-- 
cgit v1.2.3


From afb716566d04102fa6c8e1b12977d175db301081 Mon Sep 17 00:00:00 2001
From: Paroc <a.puel@proton.me>
Date: Tue, 28 Jul 2026 16:49:26 -0400
Subject: Translated using Weblate (Occitan) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/oc/

---
 .../Localization/Core/oc.json                      | 26 +++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/oc.json b/Emby.Server.Implementations/Localization/Core/oc.json
index cad5640763..4f573b3c58 100644
--- a/Emby.Server.Implementations/Localization/Core/oc.json
+++ b/Emby.Server.Implementations/Localization/Core/oc.json
@@ -1,3 +1,27 @@
 {
-    "AppDeviceValues": "Aplicacion: {0}, Periferic: {1}"
+    "AppDeviceValues": "Aplicacion: {0}, Periferic: {1}",
+    "Books": "Libres",
+    "Artists": "Artistas",
+    "Collections": "Collecciones",
+    "ChapterNameValue": "Capitol {0}",
+    "External": "Extèrn",
+    "Folders": "Dorsièrs",
+    "Favorites": "Favorits",
+    "HeaderContinueWatching": "Contunhar de regardar",
+    "HeaderFavoriteEpisodes": "Episòdis Favorits",
+    "AuthenticationSucceededWithUserName": "{0} autentificat amb succès",
+    "HeaderFavoriteShows": "Serias Favoritas",
+    "HeaderLiveTV": "TV en dirècte",
+    "HeaderNextUp": "Seguent",
+    "HearingImpaired": "Amb de deficiéncias auditivas",
+    "Movies": "Filmes",
+    "Music": "Musica",
+    "Latest": "Darrièr",
+    "Forced": "Forçat",
+    "Default": "Defaut",
+    "Genres": "Genres",
+    "HomeVideos": "Vidèos d'Acuèlh",
+    "Inherit": "Eiretar",
+    "LabelIpAddressValue": "Adreça IP: {0}",
+    "LabelRunningTimeValue": "Temps d'execucion : {0}"
 }
-- 
cgit v1.2.3


From 8293eb26b995a21f88bff60dcf93da8d98080cc0 Mon Sep 17 00:00:00 2001
From: Shadowghost <Ghost_of_Stone@web.de>
Date: Wed, 29 Jul 2026 14:40:49 +0200
Subject: Fix playlist entries being lost on migration and library scans

---
 .../Library/Resolvers/PlaylistResolver.cs          |  14 ++
 .../Item/BaseItemMapper.cs                         |   2 +-
 .../Item/ItemPersistenceService.cs                 |  56 ++++-
 .../20260113120000_MigrateLinkedChildren.cs        | 239 +++++++++++++--------
 ...29120000_RestorePlaylistChildrenFromMetadata.cs | 191 ++++++++++++++++
 MediaBrowser.Controller/Entities/Folder.cs         |  28 ++-
 6 files changed, 426 insertions(+), 104 deletions(-)
 create mode 100644 Jellyfin.Server/Migrations/Routines/20260729120000_RestorePlaylistChildrenFromMetadata.cs

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs b/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
index 74c1f69616..d6513fc79c 100644
--- a/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs
@@ -4,6 +4,7 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using Emby.Server.Implementations.Playlists;
 using Jellyfin.Data.Enums;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Library;
@@ -46,6 +47,19 @@ namespace Emby.Server.Implementations.Library.Resolvers
                     };
                 }
 
+                // Anything directly inside the internal playlists folder is a playlist, even when its
+                // playlist.xml is missing: failing to resolve here makes the library scan treat the
+                // playlist as deleted from disk and remove it, taking its items with it.
+                if (args.Parent is PlaylistsFolder)
+                {
+                    return new Playlist
+                    {
+                        Path = args.Path,
+                        Name = filename,
+                        OpenAccess = true
+                    };
+                }
+
                 // It's a directory-based playlist if the directory contains a playlist file
                 IEnumerable<string> filePaths;
                 try
diff --git a/Jellyfin.Server.Implementations/Item/BaseItemMapper.cs b/Jellyfin.Server.Implementations/Item/BaseItemMapper.cs
index c64e6ac068..958d11e21e 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemMapper.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemMapper.cs
@@ -183,7 +183,7 @@ public static class BaseItemMapper
         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)
+            if (entity.LinkedChildEntities is not null)
             {
                 folder.LinkedChildren = entity.LinkedChildEntities
                     .OrderBy(e => e.SortOrder)
diff --git a/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs b/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
index 9201a031d5..827c766449 100644
--- a/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
+++ b/Jellyfin.Server.Implementations/Item/ItemPersistenceService.cs
@@ -428,23 +428,60 @@ public class ItemPersistenceService : IItemPersistenceService
 
         foreach (var item in tuples)
         {
+            // A container that was never hydrated cannot be used to rewrite its links: its empty
+            // array means "unknown", so clearing the stored rows would silently empty the item.
+            if (item.Item is Folder { LinkedChildrenLoaded: false })
+            {
+                continue;
+            }
+
             if (item.Item is Folder or Video
                 && allLinkedChildrenByParent.TryGetValue(item.Item.Id, out var existingLinks)
                 && existingLinks.Count > 0)
             {
-                context.LinkedChildren.RemoveRange(existingLinks);
+                // A video only owns its alternate version links; any other link on that parent is
+                // written by the folder branch below and must survive.
+                var staleLinks = item.Item is Folder
+                    ? existingLinks
+                    : existingLinks
+                        .Where(e => e.ChildType is DbLinkedChildType.LocalAlternateVersion or DbLinkedChildType.LinkedAlternateVersion)
+                        .ToList();
+
+                if (staleLinks.Count > 0)
+                {
+                    context.LinkedChildren.RemoveRange(staleLinks);
+                }
             }
         }
 
         context.SaveChanges();
 
+        // A LinkedChild's ItemId is only a cache.
+        var cachedChildIds = tuples
+            .Select(t => t.Item)
+            .OfType<Folder>()
+            .Where(f => f.LinkedChildrenLoaded)
+            .SelectMany(f => f.LinkedChildren)
+            .Where(lc => lc.ItemId.HasValue && !lc.ItemId.Value.IsEmpty())
+            .Select(lc => lc.ItemId!.Value)
+            .Distinct()
+            .ToList();
+
+        var knownChildIds = cachedChildIds.Count > 0
+            ? context.BaseItems
+                .WhereOneOrMany(cachedChildIds, e => e.Id)
+                .Select(e => e.Id)
+                .ToHashSet()
+            : [];
+
         foreach (var item in tuples)
         {
-            if (item.Item is Folder folder && folder.LinkedChildren.Length > 0)
+            if (item.Item is Folder { LinkedChildrenLoaded: true } folder && 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))
+                    .Where(lc => !string.IsNullOrEmpty(lc.Path)
+                        && (!lc.ItemId.HasValue || lc.ItemId.Value.IsEmpty() || !knownChildIds.Contains(lc.ItemId.Value)))
                     .Select(lc => lc.Path)
                     .Distinct()
                     .ToList();
@@ -461,12 +498,16 @@ public class ItemPersistenceService : IItemPersistenceService
                 foreach (var linkedChild in folder.LinkedChildren)
                 {
                     var childItemId = linkedChild.ItemId;
-                    if (!childItemId.HasValue || childItemId.Value.IsEmpty())
+                    if (!childItemId.HasValue || childItemId.Value.IsEmpty() || !knownChildIds.Contains(childItemId.Value))
                     {
                         if (!string.IsNullOrEmpty(linkedChild.Path) && pathToIdMap.TryGetValue(linkedChild.Path, out var resolvedId))
                         {
                             childItemId = resolvedId;
                         }
+                        else if (Guid.TryParse(linkedChild.LibraryItemId, out var libraryItemId) && !libraryItemId.IsEmpty())
+                        {
+                            childItemId = libraryItemId;
+                        }
                     }
 #pragma warning restore CS0618
 
@@ -500,11 +541,14 @@ public class ItemPersistenceService : IItemPersistenceService
                 {
                     if (!existingChildIds.Contains(childId))
                     {
+#pragma warning disable CS0618 // Type or member is obsolete - legacy path is logged for diagnostics
                         _logger.LogWarning(
-                            "Skipping LinkedChild for parent {ParentName} ({ParentId}): child item {ChildId} does not exist in database",
+                            "Skipping LinkedChild for parent {ParentName} ({ParentId}): child item {ChildId} (path {ChildPath}) does not exist in database",
                             item.Item.Name,
                             item.Item.Id,
-                            childId);
+                            childId,
+                            linkedChild.Path ?? "unknown");
+#pragma warning restore CS0618
                         continue;
                     }
 
diff --git a/Jellyfin.Server/Migrations/Routines/20260113120000_MigrateLinkedChildren.cs b/Jellyfin.Server/Migrations/Routines/20260113120000_MigrateLinkedChildren.cs
index d13c6cf700..4a6e74c229 100644
--- a/Jellyfin.Server/Migrations/Routines/20260113120000_MigrateLinkedChildren.cs
+++ b/Jellyfin.Server/Migrations/Routines/20260113120000_MigrateLinkedChildren.cs
@@ -63,7 +63,7 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
 
         var itemsWithData = context.BaseItems
             .Where(b => b.Data != null && (containerTypes.Contains(b.Type) || videoTypes.Contains(b.Type)))
-            .Select(b => new { b.Id, b.Data, b.Type })
+            .Select(b => new { b.Id, b.Data, b.Type, b.Path, b.IsFolder })
             .ToList();
 
         _logger.LogInformation("Found {Count} potential items with LinkedChildren data to process.", itemsWithData.Count);
@@ -74,6 +74,15 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
             .GroupBy(b => b.Path!)
             .ToDictionary(g => g.Key, g => g.First().Id);
 
+        // Needed to tell a stale cached ItemId apart from one that still points at a real item.
+        var allItemIds = context.BaseItems.Select(b => b.Id).ToHashSet();
+
+        var playlistParentIds = itemsWithData
+            .Where(b => b.Type == "MediaBrowser.Controller.Playlists.Playlist")
+            .Select(b => b.Id)
+            .ToHashSet();
+
+        var droppedChildren = 0;
         var linkedChildrenToAdd = new List<LinkedChildEntity>();
         var processedCount = 0;
         const int progressLogStep = 1000;
@@ -100,7 +109,7 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
                 // Handle Video alternate versions
                 if (isVideo)
                 {
-                    ProcessVideoAlternateVersions(doc.RootElement, item.Id, pathToIdMap, linkedChildrenToAdd);
+                    ProcessVideoAlternateVersions(doc.RootElement, item.Id, pathToIdMap, allItemIds, linkedChildrenToAdd);
                 }
 
                 // Handle LinkedChildren (for containers and other items)
@@ -110,45 +119,22 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
                     continue;
                 }
 
+                // Legacy entries may hold a path relative to the container that holds them, so the
+                // container's own location has to be a real path, not a virtual one.
+                var itemPath = item.Path is null ? null : _appHost.ExpandVirtualPath(item.Path);
+                var containingFolderPath = item.IsFolder ? itemPath : Path.GetDirectoryName(itemPath);
                 var sortOrder = 0;
                 foreach (var childElement in linkedChildrenElement.EnumerateArray())
                 {
-                    Guid? childId = null;
-                    if (childElement.TryGetProperty("ItemId", out var itemIdProp) && itemIdProp.ValueKind != JsonValueKind.Null)
-                    {
-                        var itemIdStr = itemIdProp.GetString();
-                        if (!string.IsNullOrEmpty(itemIdStr) && Guid.TryParse(itemIdStr, out var parsedId))
-                        {
-                            childId = parsedId;
-                        }
-                    }
-
-                    if (!childId.HasValue || childId.Value.IsEmpty())
-                    {
-                        if (childElement.TryGetProperty("Path", out var pathProp))
-                        {
-                            var path = pathProp.GetString();
-                            if (!string.IsNullOrEmpty(path) && pathToIdMap.TryGetValue(path, out var resolvedId))
-                            {
-                                childId = resolvedId;
-                            }
-                        }
-                    }
-
-                    if (!childId.HasValue || childId.Value.IsEmpty())
-                    {
-                        if (childElement.TryGetProperty("LibraryItemId", out var libIdProp))
-                        {
-                            var libIdStr = libIdProp.GetString();
-                            if (!string.IsNullOrEmpty(libIdStr) && Guid.TryParse(libIdStr, out var parsedLibId))
-                            {
-                                childId = parsedLibId;
-                            }
-                        }
-                    }
-
-                    if (!childId.HasValue || childId.Value.IsEmpty())
+                    var childId = ResolveChildId(childElement, containingFolderPath, pathToIdMap, allItemIds);
+                    if (!childId.HasValue)
                     {
+                        droppedChildren++;
+                        _logger.LogWarning(
+                            "Dropping unresolvable LinkedChild of {ParentId}: ItemId {ItemId}, path {ChildPath}",
+                            item.Id,
+                            GetStringProperty(childElement, "ItemId") ?? "none",
+                            GetStringProperty(childElement, "Path") ?? "none");
                         continue;
                     }
 
@@ -196,23 +182,37 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
                 .Select(lc => new { lc.ParentId, lc.ChildId })
                 .ToHashSet();
 
+            // A playlist may list the same child more than once, so it cannot be keyed by
+            // (ParentId, ChildId): skip a playlist wholesale if it already has rows instead, which
+            // keeps the routine re-runnable without collapsing repeated entries.
+            var populatedParentIds = context.LinkedChildren
+                .Select(lc => lc.ParentId)
+                .Distinct()
+                .ToHashSet();
+
             var toInsert = linkedChildrenToAdd
-                .Where(lc => !existingKeys.Contains(new { lc.ParentId, lc.ChildId }))
+                .Where(lc => playlistParentIds.Contains(lc.ParentId)
+                    ? !populatedParentIds.Contains(lc.ParentId)
+                    : !existingKeys.Contains(new { lc.ParentId, lc.ChildId }))
                 .ToList();
 
             if (toInsert.Count > 0)
             {
-                // Deduplicate by composite key (ParentId, ChildId)
+                // Every container type other than a playlist keeps a single entry per child.
                 // 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();
+                toInsert =
+                [
+                    .. toInsert.Where(lc => playlistParentIds.Contains(lc.ParentId)),
+                    .. toInsert
+                        .Where(lc => !playlistParentIds.Contains(lc.ParentId))
+                        .OrderBy(lc => lc.ChildType switch
+                        {
+                            LinkedChildType.LocalAlternateVersion => 0,
+                            LinkedChildType.LinkedAlternateVersion => 1,
+                            _ => 2
+                        })
+                        .DistinctBy(lc => new { lc.ParentId, lc.ChildId })
+                ];
 
                 var childIds = toInsert.Select(lc => lc.ChildId).Distinct().ToList();
                 var existingChildIds = context.BaseItems
@@ -266,7 +266,10 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
             _logger.LogInformation("No LinkedChildren data found to migrate.");
         }
 
-        _logger.LogInformation("LinkedChildren migration completed. Processed {Count} items.", processedCount);
+        _logger.LogInformation(
+            "LinkedChildren migration completed. Processed {Count} items, dropped {DroppedCount} unresolvable children.",
+            processedCount,
+            droppedChildren);
 
         CleanupWrongTypeAlternateVersions(context);
         CleanupOrphanedAlternateVersionBaseItems(context);
@@ -417,6 +420,12 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
 
         var internalMetadataPath = _appPaths.InternalMetadataPath;
 
+        // An item outside every library location is normally left over from a removed media path, but
+        // it looks exactly the same as one whose storage failed to mount (a wrong bind mount on the
+        // first container start, for example). Only act on it while every location is readable.
+        var canRemoveUnrootedItems = inaccessiblePaths.Count == 0;
+        var skippedUnrootedItems = 0;
+
         var staleIds = new List<Guid>();
         foreach (var item in itemsWithPaths)
         {
@@ -435,6 +444,7 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
                 // Directory check covers BDMV/DVD items whose Path points to a folder
                 if (!File.Exists(path) && !Directory.Exists(path))
                 {
+                    _logger.LogDebug("Removing item {ItemId}: file {Path} no longer exists.", item.Id, path);
                     staleIds.Add(item.Id);
                 }
             }
@@ -442,12 +452,28 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
             {
                 // Item is not under ANY library location (accessible or not) —
                 // it's orphaned from all libraries (e.g. media path was removed from config)
-                staleIds.Add(item.Id);
+                if (canRemoveUnrootedItems)
+                {
+                    _logger.LogDebug("Removing item {ItemId}: path {Path} is outside every library location.", item.Id, path);
+                    staleIds.Add(item.Id);
+                }
+                else
+                {
+                    skippedUnrootedItems++;
+                }
             }
 
             // Otherwise: item is under an inaccessible location — skip (storage may be offline)
         }
 
+        if (skippedUnrootedItems > 0)
+        {
+            _logger.LogWarning(
+                "Keeping {Count} items that are outside every library location because {LocationCount} library location(s) are currently unavailable.",
+                skippedUnrootedItems,
+                inaccessiblePaths.Count);
+        }
+
         if (staleIds.Count == 0)
         {
             _logger.LogInformation("No stale items found.");
@@ -517,18 +543,86 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
             orphanedLinkedChildren.AddRange(orphanedByParent);
         }
 
-        // Remove all orphaned records
-        var distinctOrphaned = orphanedLinkedChildren.DistinctBy(lc => new { lc.ParentId, lc.ChildId }).ToList();
+        // Remove all orphaned records. Both queries can return the same row, and a playlist may hold
+        // several rows for one child, so the position is what identifies an entry here.
+        var distinctOrphaned = orphanedLinkedChildren.DistinctBy(lc => new { lc.ParentId, lc.SortOrder }).ToList();
         context.LinkedChildren.RemoveRange(distinctOrphaned);
         context.SaveChanges();
 
         _logger.LogInformation("Successfully removed {Count} orphaned LinkedChildren records.", distinctOrphaned.Count);
     }
 
+    /// <summary>
+    /// Resolves the item a legacy LinkedChild entry points at.
+    /// </summary>
+    private static Guid? ResolveChildId(
+        JsonElement childElement,
+        string? containingFolderPath,
+        Dictionary<string, Guid> pathToIdMap,
+        HashSet<Guid> allItemIds)
+    {
+        // Pre-12 data only cached ItemId and re-resolved it from the path whenever the cached value
+        // went stale (BaseItem.GetLinkedChild in 10.x). An id that no longer exists must therefore
+        // fall through to the path, or the entry is lost even though its file is still in the library.
+        if (TryGetGuidProperty(childElement, "ItemId", out var itemId) && allItemIds.Contains(itemId))
+        {
+            return itemId;
+        }
+
+        var path = GetStringProperty(childElement, "Path");
+        if (!string.IsNullOrEmpty(path))
+        {
+            if (pathToIdMap.TryGetValue(path, out var idByPath))
+            {
+                return idByPath;
+            }
+
+            // 10.x resolved entries relative to the container that holds them.
+            if (!Path.IsPathRooted(path) && !string.IsNullOrEmpty(containingFolderPath))
+            {
+                string? absolutePath = null;
+                try
+                {
+                    absolutePath = Path.GetFullPath(Path.Combine(containingFolderPath, path));
+                }
+                catch (ArgumentException)
+                {
+                    // Malformed path, nothing to resolve.
+                }
+
+                if (absolutePath is not null && pathToIdMap.TryGetValue(absolutePath, out var idByAbsolutePath))
+                {
+                    return idByAbsolutePath;
+                }
+            }
+        }
+
+        if (TryGetGuidProperty(childElement, "LibraryItemId", out var libraryItemId) && allItemIds.Contains(libraryItemId))
+        {
+            return libraryItemId;
+        }
+
+        return null;
+    }
+
+    private static string? GetStringProperty(JsonElement element, string propertyName)
+        => element.TryGetProperty(propertyName, out var property) && property.ValueKind == JsonValueKind.String
+            ? property.GetString()
+            : null;
+
+    private static bool TryGetGuidProperty(JsonElement element, string propertyName, out Guid value)
+    {
+        value = Guid.Empty;
+        var raw = GetStringProperty(element, propertyName);
+
+        return !string.IsNullOrEmpty(raw) && Guid.TryParse(raw, out value) && !value.IsEmpty();
+    }
+
     private void ProcessVideoAlternateVersions(
         JsonElement root,
         Guid parentId,
         Dictionary<string, Guid> pathToIdMap,
+        HashSet<Guid> allItemIds,
         List<LinkedChildEntity> linkedChildrenToAdd)
     {
         int sortOrder = 0;
@@ -581,45 +675,8 @@ internal class MigrateLinkedChildren : IDatabaseMigrationRoutine
         {
             foreach (var linkedChildElement in linkedAlternateVersionsElement.EnumerateArray())
             {
-                Guid? childId = null;
-
-                // Try to get ItemId
-                if (linkedChildElement.TryGetProperty("ItemId", out var itemIdProp) && itemIdProp.ValueKind != JsonValueKind.Null)
-                {
-                    var itemIdStr = itemIdProp.GetString();
-                    if (!string.IsNullOrEmpty(itemIdStr) && Guid.TryParse(itemIdStr, out var parsedId))
-                    {
-                        childId = parsedId;
-                    }
-                }
-
-                // Try to get from Path if ItemId not available
-                if (!childId.HasValue || childId.Value.IsEmpty())
-                {
-                    if (linkedChildElement.TryGetProperty("Path", out var pathProp))
-                    {
-                        var path = pathProp.GetString();
-                        if (!string.IsNullOrEmpty(path) && pathToIdMap.TryGetValue(path, out var resolvedId))
-                        {
-                            childId = resolvedId;
-                        }
-                    }
-                }
-
-                // Try LibraryItemId as fallback
-                if (!childId.HasValue || childId.Value.IsEmpty())
-                {
-                    if (linkedChildElement.TryGetProperty("LibraryItemId", out var libIdProp))
-                    {
-                        var libIdStr = libIdProp.GetString();
-                        if (!string.IsNullOrEmpty(libIdStr) && Guid.TryParse(libIdStr, out var parsedLibId))
-                        {
-                            childId = parsedLibId;
-                        }
-                    }
-                }
-
-                if (!childId.HasValue || childId.Value.IsEmpty())
+                var childId = ResolveChildId(linkedChildElement, null, pathToIdMap, allItemIds);
+                if (!childId.HasValue)
                 {
                     _logger.LogWarning("Could not resolve LinkedAlternateVersion child ID for parent {ParentId}", parentId);
                     continue;
diff --git a/Jellyfin.Server/Migrations/Routines/20260729120000_RestorePlaylistChildrenFromMetadata.cs b/Jellyfin.Server/Migrations/Routines/20260729120000_RestorePlaylistChildrenFromMetadata.cs
new file mode 100644
index 0000000000..16ac6cb5e5
--- /dev/null
+++ b/Jellyfin.Server/Migrations/Routines/20260729120000_RestorePlaylistChildrenFromMetadata.cs
@@ -0,0 +1,191 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Xml;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using MediaBrowser.Controller;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Server.Migrations.Routines;
+
+/// <summary>
+/// Restores playlist entries from playlist.xml for playlists that lost all of their children.
+/// </summary>
+[JellyfinMigration("2026-07-29T12:00:00", nameof(RestorePlaylistChildrenFromMetadata))]
+internal class RestorePlaylistChildrenFromMetadata : IDatabaseMigrationRoutine
+{
+    private const string PlaylistTypeName = "MediaBrowser.Controller.Playlists.Playlist";
+    private const string PlaylistFileName = "playlist.xml";
+
+    private readonly ILogger<RestorePlaylistChildrenFromMetadata> _logger;
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IServerApplicationHost _appHost;
+
+    public RestorePlaylistChildrenFromMetadata(
+        ILoggerFactory loggerFactory,
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IServerApplicationHost appHost)
+    {
+        _logger = loggerFactory.CreateLogger<RestorePlaylistChildrenFromMetadata>();
+        _dbProvider = dbProvider;
+        _appHost = appHost;
+    }
+
+    /// <inheritdoc/>
+    public void Perform()
+    {
+        using var context = _dbProvider.CreateDbContext();
+
+        var playlists = context.BaseItems
+            .Where(b => b.Type == PlaylistTypeName && b.Path != null)
+            .Select(b => new { b.Id, b.Name, b.Path })
+            .ToList();
+
+        if (playlists.Count == 0)
+        {
+            return;
+        }
+
+        var childCountByPlaylist = context.LinkedChildren
+            .Where(lc => context.BaseItems.Any(b => b.Id.Equals(lc.ParentId) && b.Type == PlaylistTypeName))
+            .GroupBy(lc => lc.ParentId)
+            .Select(g => new { ParentId = g.Key, Count = g.Count() })
+            .ToDictionary(g => g.ParentId, g => g.Count);
+
+        var pathToIdMap = context.BaseItems
+            .Where(b => b.Path != null)
+            .Select(b => new { b.Id, b.Path })
+            .GroupBy(b => b.Path!)
+            .ToDictionary(g => g.Key, g => g.First().Id);
+
+        var restoredPlaylists = 0;
+        var restoredEntries = 0;
+
+        foreach (var playlist in playlists)
+        {
+            // Only directory-based (Jellyfin-managed) playlists keep their entries in playlist.xml.
+            // A playlist that is itself a file (.m3u and friends) is re-read by the library scan.
+            var playlistPath = _appHost.ExpandVirtualPath(playlist.Path!);
+            var metadataPath = Path.Combine(playlistPath, PlaylistFileName);
+            if (!Directory.Exists(playlistPath) || !File.Exists(metadataPath))
+            {
+                continue;
+            }
+
+            var storedPaths = ReadEntryPaths(metadataPath, playlist.Id);
+            if (storedPaths.Count == 0)
+            {
+                continue;
+            }
+
+            var childCount = childCountByPlaylist.GetValueOrDefault(playlist.Id);
+            if (childCount > 0)
+            {
+                // Merging into a playlist that still has entries would resurrect anything the user
+                // removed while the metadata file was not rewritten, and there is no way to tell the
+                // two apart. Report the mismatch instead so it can be checked by hand.
+                if (storedPaths.Count > childCount)
+                {
+                    _logger.LogWarning(
+                        "Playlist {PlaylistName} ({PlaylistId}) holds {ChildCount} entries but {MetadataPath} lists {StoredCount}. Not restoring automatically.",
+                        playlist.Name,
+                        playlist.Id,
+                        childCount,
+                        metadataPath,
+                        storedPaths.Count);
+                }
+
+                continue;
+            }
+
+            var sortOrder = 0;
+            foreach (var storedPath in storedPaths)
+            {
+                if (!pathToIdMap.TryGetValue(storedPath, out var childId))
+                {
+                    _logger.LogWarning(
+                        "Cannot restore entry {EntryPath} of playlist {PlaylistName}: no library item has that path.",
+                        storedPath,
+                        playlist.Name);
+                    continue;
+                }
+
+                context.LinkedChildren.Add(new LinkedChildEntity
+                {
+                    ParentId = playlist.Id,
+                    ChildId = childId,
+                    ChildType = LinkedChildType.Manual,
+                    SortOrder = sortOrder
+                });
+
+                sortOrder++;
+            }
+
+            if (sortOrder > 0)
+            {
+                restoredPlaylists++;
+                restoredEntries += sortOrder;
+                _logger.LogInformation(
+                    "Restored {Count} entries of empty playlist {PlaylistName} ({PlaylistId}) from {MetadataPath}.",
+                    sortOrder,
+                    playlist.Name,
+                    playlist.Id,
+                    metadataPath);
+            }
+        }
+
+        if (restoredEntries > 0)
+        {
+            context.SaveChanges();
+            _logger.LogInformation("Restored {EntryCount} entries across {PlaylistCount} playlists.", restoredEntries, restoredPlaylists);
+        }
+    }
+
+    private List<string> ReadEntryPaths(string metadataPath, Guid playlistId)
+    {
+        var paths = new List<string>();
+        var settings = new XmlReaderSettings
+        {
+            IgnoreComments = true,
+            IgnoreWhitespace = true,
+            IgnoreProcessingInstructions = true,
+            DtdProcessing = DtdProcessing.Prohibit
+        };
+
+        try
+        {
+            using var reader = XmlReader.Create(metadataPath, settings);
+            var inEntry = false;
+            while (reader.Read())
+            {
+                if (reader.NodeType != XmlNodeType.Element)
+                {
+                    continue;
+                }
+
+                if (string.Equals(reader.Name, "PlaylistItem", StringComparison.Ordinal))
+                {
+                    inEntry = true;
+                }
+                else if (inEntry && string.Equals(reader.Name, "Path", StringComparison.Ordinal))
+                {
+                    inEntry = false;
+                    var value = reader.ReadElementContentAsString();
+                    if (!string.IsNullOrWhiteSpace(value))
+                    {
+                        paths.Add(value.Trim());
+                    }
+                }
+            }
+        }
+        catch (Exception ex) when (ex is XmlException or IOException or UnauthorizedAccessException)
+        {
+            _logger.LogWarning(ex, "Could not read playlist metadata {MetadataPath} of playlist {PlaylistId}.", metadataPath, playlistId);
+        }
+
+        return paths;
+    }
+}
diff --git a/MediaBrowser.Controller/Entities/Folder.cs b/MediaBrowser.Controller/Entities/Folder.cs
index b1f7f29bad..f475379cc3 100644
--- a/MediaBrowser.Controller/Entities/Folder.cs
+++ b/MediaBrowser.Controller/Entities/Folder.cs
@@ -43,11 +43,7 @@ namespace MediaBrowser.Controller.Entities
     public class Folder : BaseItem
     {
         private IEnumerable<BaseItem> _children;
-
-        public Folder()
-        {
-            LinkedChildren = Array.Empty<LinkedChild>();
-        }
+        private LinkedChild[] _linkedChildren = [];
 
         public static IUserViewManager UserViewManager { get; set; }
 
@@ -63,7 +59,27 @@ namespace MediaBrowser.Controller.Entities
         /// Gets or sets the linked children.
         /// </summary>
         [JsonIgnore]
-        public LinkedChild[] LinkedChildren { get; set; }
+        public LinkedChild[] LinkedChildren
+        {
+            get => _linkedChildren;
+            set
+            {
+                _linkedChildren = value;
+
+                // Assigning the collection means the caller knows the complete set of links.
+                LinkedChildrenLoaded = true;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether <see cref="LinkedChildren"/> holds the stored set of links.
+        /// </summary>
+        /// <remarks>
+        /// An unloaded instance carries an empty array that means "unknown", not "no children" —
+        /// persisting it would delete every link the item has.
+        /// </remarks>
+        [JsonIgnore]
+        public bool LinkedChildrenLoaded { get; private set; }
 
         [JsonIgnore]
         public DateTime? DateLastMediaAdded { get; set; }
-- 
cgit v1.2.3


From b15d3c9ad31d6a2f7e940d0372d9f3b93c5f9e95 Mon Sep 17 00:00:00 2001
From: krvi <27792771+krvi@users.noreply.github.com>
Date: Wed, 29 Jul 2026 20:41:17 -0400
Subject: Translated using Weblate (Faroese) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/fo/

---
 Emby.Server.Implementations/Localization/Core/fo.json | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/fo.json b/Emby.Server.Implementations/Localization/Core/fo.json
index d2bba38cb7..575d3a4a77 100644
--- a/Emby.Server.Implementations/Localization/Core/fo.json
+++ b/Emby.Server.Implementations/Localization/Core/fo.json
@@ -51,5 +51,15 @@
     "Music": "Tónleikur",
     "UserStartedPlayingItemWithValues": "{0} spælur {1} á {2}",
     "HeaderContinueWatching": "Hald áfram at hyggja",
-    "MusicVideos": "Sjónbandaløg"
+    "MusicVideos": "Sjónbandaløg",
+    "TaskUpdatePluginsDescription": "Niðurtekur og innleggur dagføringar til ískoytisforrit ið eru stillaði til at dagførast sjálvvirkandi.",
+    "TaskCleanTranscodeDescription": "Strikar umkotaðar fílar ið eru eldri enn 1 dag.",
+    "TaskOptimizeDatabase": "Albøt dátugrunn",
+    "NameSeasonNumber": "Sesong {0}",
+    "NameSeasonUnknown": "Ókend sesong",
+    "ScheduledTaskFailedWithName": "{0} miseydnaðist",
+    "Undefined": "Óskilmarkað",
+    "TasksMaintenanceCategory": "Viðlíkahald",
+    "TaskCleanLogs": "Reinsa gerðalistaskjáttu",
+    "UserOnlineFromDevice": "{0} er íbundin frá {1}"
 }
-- 
cgit v1.2.3


From b2ae39e0d911dd8065c4504a82b00965a18c6bfd Mon Sep 17 00:00:00 2001
From: krvi <27792771+krvi@users.noreply.github.com>
Date: Thu, 30 Jul 2026 21:11:22 -0400
Subject: Translated using Weblate (Faroese) Translation: Jellyfin/Jellyfin
 Translate-URL:
 https://translate.jellyfin.org/projects/jellyfin/jellyfin-core/fo/

---
 Emby.Server.Implementations/Localization/Core/fo.json | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

(limited to 'Emby.Server.Implementations')

diff --git a/Emby.Server.Implementations/Localization/Core/fo.json b/Emby.Server.Implementations/Localization/Core/fo.json
index 575d3a4a77..cbfba08f41 100644
--- a/Emby.Server.Implementations/Localization/Core/fo.json
+++ b/Emby.Server.Implementations/Localization/Core/fo.json
@@ -61,5 +61,13 @@
     "Undefined": "Óskilmarkað",
     "TasksMaintenanceCategory": "Viðlíkahald",
     "TaskCleanLogs": "Reinsa gerðalistaskjáttu",
-    "UserOnlineFromDevice": "{0} er íbundin frá {1}"
+    "UserOnlineFromDevice": "{0} er íbundin frá {1}",
+    "HeaderNextUp": "Næst á skránni",
+    "NotificationOptionPluginError": "Brek í ískoytisforriti",
+    "NotificationOptionInstallationFailed": "Innleggingarbrek",
+    "NotificationOptionServerRestartRequired": "Tørvur er á ambætaraendurbyrjan",
+    "TasksApplicationCategory": "Nýtsluskipan",
+    "NotificationOptionApplicationUpdateAvailable": "Skipanardagføring er tøk",
+    "NotificationOptionApplicationUpdateInstalled": "Skipanardagføring varð innløgd",
+    "UserStoppedPlayingItemWithValues": "{0} er liðugur at spæla {1} á {2}"
 }
-- 
cgit v1.2.3