From da31d0c6a61ff0d908ad3c9ddcfa42a055f7ef6f Mon Sep 17 00:00:00 2001
From: Cody Engel <cengel815@gmail.com>
Date: Sat, 20 Sep 2025 14:04:00 -0600
Subject: support series that are numeric only

updates SeriesResolver to handle series names that only contain numbers such as 1923.
---
 tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'tests')

diff --git a/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs b/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs
index 84758c9c3..84311b0e2 100644
--- a/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs
+++ b/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs
@@ -19,6 +19,8 @@ namespace Jellyfin.Naming.Tests.TV
         [InlineData("/some/path/The Show", "The Show")]
         [InlineData("/some/path/The Show s02e10 720p hdtv", "The Show")]
         [InlineData("/some/path/The Show s02e10 the episode 720p hdtv", "The Show")]
+        [InlineData("/some/path/1923 (2022)", "1923")]
+        [InlineData("/some/path/-1923 (2022)", "1923")]
         public void SeriesResolverResolveTest(string path, string name)
         {
             var res = SeriesResolver.Resolve(_namingOptions, path);
-- 
cgit v1.2.3


From bd9a44ce7d45bf00d928ccfb13a2695686b91264 Mon Sep 17 00:00:00 2001
From: Cody Engel <cengel815@gmail.com>
Date: Sat, 20 Sep 2025 18:00:44 -0600
Subject: remove explicit ‘-‘ support in series name
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Emby.Naming/TV/SeriesResolver.cs                      | 2 +-
 tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

(limited to 'tests')

diff --git a/Emby.Naming/TV/SeriesResolver.cs b/Emby.Naming/TV/SeriesResolver.cs
index 795c63509..6ec420a37 100644
--- a/Emby.Naming/TV/SeriesResolver.cs
+++ b/Emby.Naming/TV/SeriesResolver.cs
@@ -21,7 +21,7 @@ namespace Emby.Naming.TV
         /// Regex that matches titles with year in parentheses, optionally preceded by a minus sign.
         /// Captures the title (which may be numeric) before the year.
         /// </summary>
-        [GeneratedRegex(@"^-?(?<title>.+?)\s*\(\d{4}\)")]
+        [GeneratedRegex(@"(?<title>.+?)\s*\(\d{4}\)")]
         private static partial Regex TitleWithYearRegex();
 
         /// <summary>
diff --git a/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs b/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs
index 84311b0e2..b81b7934c 100644
--- a/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs
+++ b/tests/Jellyfin.Naming.Tests/TV/SeriesResolverTests.cs
@@ -20,7 +20,6 @@ namespace Jellyfin.Naming.Tests.TV
         [InlineData("/some/path/The Show s02e10 720p hdtv", "The Show")]
         [InlineData("/some/path/The Show s02e10 the episode 720p hdtv", "The Show")]
         [InlineData("/some/path/1923 (2022)", "1923")]
-        [InlineData("/some/path/-1923 (2022)", "1923")]
         public void SeriesResolverResolveTest(string path, string name)
         {
             var res = SeriesResolver.Resolve(_namingOptions, path);
-- 
cgit v1.2.3


From 0fb6d930e1ca14d1d3af06ecee310869d2e86dfe Mon Sep 17 00:00:00 2001
From: Niels van Velzen <git@ndat.nl>
Date: Sun, 5 Oct 2025 10:59:10 +0200
Subject: Deprecate HasPassword property on UserDto

---
 .../Users/DefaultAuthenticationProvider.cs         |  6 +---
 .../Users/InvalidAuthProvider.cs                   |  6 ----
 .../Users/UserManager.cs                           |  3 --
 .../Authentication/IAuthenticationProvider.cs      |  2 --
 MediaBrowser.Model/Dto/UserDto.cs                  |  9 ++++--
 .../Controllers/UserControllerTests.cs             | 32 ----------------------
 6 files changed, 7 insertions(+), 51 deletions(-)

(limited to 'tests')

diff --git a/Jellyfin.Server.Implementations/Users/DefaultAuthenticationProvider.cs b/Jellyfin.Server.Implementations/Users/DefaultAuthenticationProvider.cs
index 35c43b176..446849b6f 100644
--- a/Jellyfin.Server.Implementations/Users/DefaultAuthenticationProvider.cs
+++ b/Jellyfin.Server.Implementations/Users/DefaultAuthenticationProvider.cs
@@ -59,7 +59,7 @@ namespace Jellyfin.Server.Implementations.Users
             }
 
             // As long as jellyfin supports password-less users, we need this little block here to accommodate
-            if (!HasPassword(resolvedUser) && string.IsNullOrEmpty(password))
+            if (string.IsNullOrEmpty(resolvedUser.Password) && string.IsNullOrEmpty(password))
             {
                 return Task.FromResult(new ProviderAuthenticationResult
                 {
@@ -93,10 +93,6 @@ namespace Jellyfin.Server.Implementations.Users
             });
         }
 
-        /// <inheritdoc />
-        public bool HasPassword(User user)
-            => !string.IsNullOrEmpty(user?.Password);
-
         /// <inheritdoc />
         public Task ChangePassword(User user, string newPassword)
         {
diff --git a/Jellyfin.Server.Implementations/Users/InvalidAuthProvider.cs b/Jellyfin.Server.Implementations/Users/InvalidAuthProvider.cs
index caf9d5bd9..56b8a7fc4 100644
--- a/Jellyfin.Server.Implementations/Users/InvalidAuthProvider.cs
+++ b/Jellyfin.Server.Implementations/Users/InvalidAuthProvider.cs
@@ -21,12 +21,6 @@ namespace Jellyfin.Server.Implementations.Users
             throw new AuthenticationException("User Account cannot login with this provider. The Normal provider for this user cannot be found");
         }
 
-        /// <inheritdoc />
-        public bool HasPassword(User user)
-        {
-            return true;
-        }
-
         /// <inheritdoc />
         public Task ChangePassword(User user, string newPassword)
         {
diff --git a/Jellyfin.Server.Implementations/Users/UserManager.cs b/Jellyfin.Server.Implementations/Users/UserManager.cs
index d0b41a7f6..9f36624bc 100644
--- a/Jellyfin.Server.Implementations/Users/UserManager.cs
+++ b/Jellyfin.Server.Implementations/Users/UserManager.cs
@@ -306,15 +306,12 @@ namespace Jellyfin.Server.Implementations.Users
         /// <inheritdoc/>
         public UserDto GetUserDto(User user, string? remoteEndPoint = null)
         {
-            var hasPassword = GetAuthenticationProvider(user).HasPassword(user);
             var castReceiverApplications = _serverConfigurationManager.Configuration.CastReceiverApplications;
             return new UserDto
             {
                 Name = user.Username,
                 Id = user.Id,
                 ServerId = _appHost.SystemId,
-                HasPassword = hasPassword,
-                HasConfiguredPassword = hasPassword,
                 EnableAutoLogin = user.EnableAutoLogin,
                 LastLoginDate = user.LastLoginDate,
                 LastActivityDate = user.LastActivityDate,
diff --git a/MediaBrowser.Controller/Authentication/IAuthenticationProvider.cs b/MediaBrowser.Controller/Authentication/IAuthenticationProvider.cs
index 976a667ac..c993ceea8 100644
--- a/MediaBrowser.Controller/Authentication/IAuthenticationProvider.cs
+++ b/MediaBrowser.Controller/Authentication/IAuthenticationProvider.cs
@@ -14,8 +14,6 @@ namespace MediaBrowser.Controller.Authentication
 
         Task<ProviderAuthenticationResult> Authenticate(string username, string password);
 
-        bool HasPassword(User user);
-
         Task ChangePassword(User user, string newPassword);
     }
 
diff --git a/MediaBrowser.Model/Dto/UserDto.cs b/MediaBrowser.Model/Dto/UserDto.cs
index 05019741e..c6b4a4d14 100644
--- a/MediaBrowser.Model/Dto/UserDto.cs
+++ b/MediaBrowser.Model/Dto/UserDto.cs
@@ -1,5 +1,6 @@
 #nullable disable
 using System;
+using System.ComponentModel;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Users;
 
@@ -54,20 +55,22 @@ namespace MediaBrowser.Model.Dto
         /// Gets or sets a value indicating whether this instance has password.
         /// </summary>
         /// <value><c>true</c> if this instance has password; otherwise, <c>false</c>.</value>
-        public bool HasPassword { get; set; }
+        [Obsolete("This information is no longer provided")]
+        public bool? HasPassword { get; set; } = true;
 
         /// <summary>
         /// Gets or sets a value indicating whether this instance has configured password.
         /// </summary>
         /// <value><c>true</c> if this instance has configured password; otherwise, <c>false</c>.</value>
-        public bool HasConfiguredPassword { get; set; }
+        [Obsolete("This is always true")]
+        public bool? HasConfiguredPassword { get; set; } = true;
 
         /// <summary>
         /// Gets or sets a value indicating whether this instance has configured easy password.
         /// </summary>
         /// <value><c>true</c> if this instance has configured easy password; otherwise, <c>false</c>.</value>
         [Obsolete("Easy Password has been replaced with Quick Connect")]
-        public bool HasConfiguredEasyPassword { get; set; }
+        public bool? HasConfiguredEasyPassword { get; set; } = false;
 
         /// <summary>
         /// Gets or sets whether async login is enabled or not.
diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs
index 16c63ed49..4278fd069 100644
--- a/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs
@@ -61,7 +61,6 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
             var users = await response.Content.ReadFromJsonAsync<UserDto[]>(_jsonOptions);
             Assert.NotNull(users);
             Assert.Single(users);
-            Assert.False(users![0].HasConfiguredPassword);
         }
 
         [Fact]
@@ -92,8 +91,6 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
             Assert.Equal(HttpStatusCode.OK, response.StatusCode);
             var user = await response.Content.ReadFromJsonAsync<UserDto>(_jsonOptions);
             Assert.Equal(TestUsername, user!.Name);
-            Assert.False(user.HasPassword);
-            Assert.False(user.HasConfiguredPassword);
 
             _testUserId = user.Id;
 
@@ -149,35 +146,6 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
 
             using var response = await UpdateUserPassword(client, _testUserId, createRequest);
             Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
-
-            var users = await JsonSerializer.DeserializeAsync<UserDto[]>(
-                await client.GetStreamAsync("Users"), _jsonOptions);
-            var user = users!.First(x => x.Id.Equals(_testUserId));
-            Assert.True(user.HasPassword);
-            Assert.True(user.HasConfiguredPassword);
-        }
-
-        [Fact]
-        [Priority(2)]
-        public async Task UpdateUserPassword_Empty_RemoveSetPassword()
-        {
-            var client = _factory.CreateClient();
-
-            client.DefaultRequestHeaders.AddAuthHeader(_accessToken!);
-
-            var createRequest = new UpdateUserPassword()
-            {
-                CurrentPw = "4randomPa$$word",
-            };
-
-            using var response = await UpdateUserPassword(client, _testUserId, createRequest);
-            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
-
-            var users = await JsonSerializer.DeserializeAsync<UserDto[]>(
-                await client.GetStreamAsync("Users"), _jsonOptions);
-            var user = users!.First(x => x.Id.Equals(_testUserId));
-            Assert.False(user.HasPassword);
-            Assert.False(user.HasConfiguredPassword);
         }
     }
 }
-- 
cgit v1.2.3


From d43db230fa1ff6f371a9ab16063152f5b632e2e9 Mon Sep 17 00:00:00 2001
From: Niels van Velzen <git@ndat.nl>
Date: Sun, 19 Oct 2025 09:45:55 +0200
Subject: Add back UpdateUserPassword_Empty_RemoveSetPassword test

---
 .../Controllers/UserControllerTests.cs                  | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

(limited to 'tests')

diff --git a/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs b/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs
index 4278fd069..04d1b3dc2 100644
--- a/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs
+++ b/tests/Jellyfin.Server.Integration.Tests/Controllers/UserControllerTests.cs
@@ -147,5 +147,22 @@ namespace Jellyfin.Server.Integration.Tests.Controllers
             using var response = await UpdateUserPassword(client, _testUserId, createRequest);
             Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
         }
+
+        [Fact]
+        [Priority(2)]
+        public async Task UpdateUserPassword_Empty_RemoveSetPassword()
+        {
+            var client = _factory.CreateClient();
+
+            client.DefaultRequestHeaders.AddAuthHeader(_accessToken!);
+
+            var createRequest = new UpdateUserPassword()
+            {
+                CurrentPw = "4randomPa$$word",
+            };
+
+            using var response = await UpdateUserPassword(client, _testUserId, createRequest);
+            Assert.Equal(HttpStatusCode.NoContent, response.StatusCode);
+        }
     }
 }
-- 
cgit v1.2.3


From 3c4dc16003bedb5201b0fa68652421c625523a15 Mon Sep 17 00:00:00 2001
From: theguymadmax <171496228+theguymadmax@users.noreply.github.com>
Date: Mon, 27 Oct 2025 15:43:12 -0400
Subject: Backport pull request #15102 from jellyfin/release-10.11.z

Make season paths case-insensitive

Original-merge: 305b0fdca323833653dd26c642b2c465890143dc

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Bond_009 <bond.009@outlook.com>
---
 Emby.Naming/TV/SeasonPathParser.cs                     |  6 +++---
 .../Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs  | 18 ++++++++++++++++++
 2 files changed, 21 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/Emby.Naming/TV/SeasonPathParser.cs b/Emby.Naming/TV/SeasonPathParser.cs
index 98ee1e4b8..90aae2d48 100644
--- a/Emby.Naming/TV/SeasonPathParser.cs
+++ b/Emby.Naming/TV/SeasonPathParser.cs
@@ -10,10 +10,10 @@ namespace Emby.Naming.TV
     /// </summary>
     public static partial class SeasonPathParser
     {
-        [GeneratedRegex(@"^\s*((?<seasonnumber>(?>\d+))(?:st|nd|rd|th|\.)*(?!\s*[Ee]\d+))\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<rightpart>.*)$")]
+        [GeneratedRegex(@"^\s*((?<seasonnumber>(?>\d+))(?:st|nd|rd|th|\.)*(?!\s*[Ee]\d+))\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
         private static partial Regex ProcessPre();
 
-        [GeneratedRegex(@"^\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<seasonnumber>(?>\d+)(?!\s*[Ee]\d+))(?<rightpart>.*)$")]
+        [GeneratedRegex(@"^\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<seasonnumber>(?>\d+)(?!\s*[Ee]\d+))(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
         private static partial Regex ProcessPost();
 
         /// <summary>
@@ -86,7 +86,7 @@ namespace Emby.Naming.TV
                 }
             }
 
-            if (filename.StartsWith('s'))
+            if (filename.Length > 0 && (filename[0] == 'S' || filename[0] == 's'))
             {
                 var testFilename = filename.AsSpan()[1..];
 
diff --git a/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs b/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
index 4c8ba58d0..7671166ff 100644
--- a/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
+++ b/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
@@ -7,23 +7,38 @@ public class SeasonPathParserTests
 {
     [Theory]
     [InlineData("/Drive/Season 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SEASON 1", "/Drive", 1, true)]
     [InlineData("/Drive/Staffel 1", "/Drive", 1, true)]
+    [InlineData("/Drive/STAFFEL 1", "/Drive", 1, true)]
     [InlineData("/Drive/Stagione 1", "/Drive", 1, true)]
+    [InlineData("/Drive/STAGIONE 1", "/Drive", 1, true)]
     [InlineData("/Drive/sæson 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SÆSON 1", "/Drive", 1, true)]
     [InlineData("/Drive/Temporada 1", "/Drive", 1, true)]
+    [InlineData("/Drive/TEMPORADA 1", "/Drive", 1, true)]
     [InlineData("/Drive/series 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SERIES 1", "/Drive", 1, true)]
     [InlineData("/Drive/Kausi 1", "/Drive", 1, true)]
+    [InlineData("/Drive/KAUSI 1", "/Drive", 1, true)]
     [InlineData("/Drive/Säsong 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SÄSONG 1", "/Drive", 1, true)]
     [InlineData("/Drive/Seizoen 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SEIZOEN 1", "/Drive", 1, true)]
     [InlineData("/Drive/Seasong 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SEASONG 1", "/Drive", 1, true)]
     [InlineData("/Drive/Sezon 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SEZON 1", "/Drive", 1, true)]
     [InlineData("/Drive/sezona 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SEZONA 1", "/Drive", 1, true)]
     [InlineData("/Drive/sezóna 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SEZÓNA 1", "/Drive", 1, true)]
     [InlineData("/Drive/Sezonul 1", "/Drive", 1, true)]
+    [InlineData("/Drive/SEZONUL 1", "/Drive", 1, true)]
     [InlineData("/Drive/시즌 1", "/Drive", 1, true)]
     [InlineData("/Drive/シーズン 1", "/Drive", 1, true)]
     [InlineData("/Drive/сезон 1", "/Drive", 1, true)]
     [InlineData("/Drive/Сезон 1", "/Drive", 1, true)]
+    [InlineData("/Drive/СЕЗОН 1", "/Drive", 1, true)]
     [InlineData("/Drive/Season 10", "/Drive", 10, true)]
     [InlineData("/Drive/Season 100", "/Drive", 100, true)]
     [InlineData("/Drive/s1", "/Drive", 1, true)]
@@ -46,8 +61,11 @@ public class SeasonPathParserTests
     [InlineData("/Drive/s06e05", "/Drive", null, false)]
     [InlineData("/Drive/The.Legend.of.Condor.Heroes.2017.V2.web-dl.1080p.h264.aac-hdctv", "/Drive", null, false)]
     [InlineData("/Drive/extras", "/Drive", 0, true)]
+    [InlineData("/Drive/EXTRAS", "/Drive", 0, true)]
     [InlineData("/Drive/specials", "/Drive", 0, true)]
+    [InlineData("/Drive/SPECIALS", "/Drive", 0, true)]
     [InlineData("/Drive/Episode 1 Season 2", "/Drive", null, false)]
+    [InlineData("/Drive/Episode 1 SEASON 2", "/Drive", null, false)]
     public void GetSeasonNumberFromPathTest(string path, string? parentPath, int? seasonNumber, bool isSeasonDirectory)
     {
         var result = SeasonPathParser.Parse(path, parentPath, true, true);
-- 
cgit v1.2.3


From 87b02b13166b5dc8cd59e273e1c82339db940a27 Mon Sep 17 00:00:00 2001
From: Shadowghost <Shadowghost@users.noreply.github.com>
Date: Sun, 2 Nov 2025 21:58:45 -0500
Subject: Backport pull request #15326 from jellyfin/release-10.11.z

Skip too large extracted season numbers

Original-merge: e7dbb3afec3282c556e4fe35d9376ecaa4417171

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Joshua M. Boniface <joshua@boniface.me>
---
 Emby.Naming/TV/SeasonPathParser.cs                      | 6 ++++--
 tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs | 3 +++
 2 files changed, 7 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/Emby.Naming/TV/SeasonPathParser.cs b/Emby.Naming/TV/SeasonPathParser.cs
index 90aae2d48..eafb09a6a 100644
--- a/Emby.Naming/TV/SeasonPathParser.cs
+++ b/Emby.Naming/TV/SeasonPathParser.cs
@@ -113,8 +113,10 @@ namespace Emby.Naming.TV
             var numberString = match.Groups["seasonnumber"];
             if (numberString.Success)
             {
-                var seasonNumber = int.Parse(numberString.Value, CultureInfo.InvariantCulture);
-                return (seasonNumber, true);
+                if (int.TryParse(numberString.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var seasonNumber))
+                {
+                    return (seasonNumber, true);
+                }
             }
 
             return (null, false);
diff --git a/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs b/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
index 7671166ff..0c3671f4f 100644
--- a/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
+++ b/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
@@ -66,6 +66,9 @@ public class SeasonPathParserTests
     [InlineData("/Drive/SPECIALS", "/Drive", 0, true)]
     [InlineData("/Drive/Episode 1 Season 2", "/Drive", null, false)]
     [InlineData("/Drive/Episode 1 SEASON 2", "/Drive", null, false)]
+    [InlineData("/media/YouTube/Devyn Johnston/2024-01-24 4070 Ti SUPER in under 7 minutes", "/media/YouTube/Devyn Johnston", null, false)]
+    [InlineData("/media/YouTube/Devyn Johnston/2025-01-28 5090 vs 2 SFF Cases", "/media/YouTube/Devyn Johnston", null, false)]
+    [InlineData("/Drive/202401244070", "/Drive", null, false)]
     public void GetSeasonNumberFromPathTest(string path, string? parentPath, int? seasonNumber, bool isSeasonDirectory)
     {
         var result = SeasonPathParser.Parse(path, parentPath, true, true);
-- 
cgit v1.2.3


From 6c5f44878756414716b553cf66767a988816a2a8 Mon Sep 17 00:00:00 2001
From: theguymadmax <171496228+theguymadmax@users.noreply.github.com>
Date: Mon, 17 Nov 2025 14:08:54 -0500
Subject: Backport pull request #15404 from jellyfin/release-10.11.z

Improve season folder parsing

Original-merge: 2e5ced50986c37b19b5f4ef34d730fc56a51535a

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Bond_009 <bond.009@outlook.com>
---
 Emby.Naming/TV/SeasonPathParser.cs                 | 51 ++++++++++------------
 .../TV/SeasonPathParserTests.cs                    |  6 +++
 2 files changed, 29 insertions(+), 28 deletions(-)

(limited to 'tests')

diff --git a/Emby.Naming/TV/SeasonPathParser.cs b/Emby.Naming/TV/SeasonPathParser.cs
index eafb09a6a..72adfb2d9 100644
--- a/Emby.Naming/TV/SeasonPathParser.cs
+++ b/Emby.Naming/TV/SeasonPathParser.cs
@@ -10,12 +10,17 @@ namespace Emby.Naming.TV
     /// </summary>
     public static partial class SeasonPathParser
     {
+        private static readonly Regex CleanNameRegex = new(@"[ ._\-\[\]]", RegexOptions.Compiled);
+
         [GeneratedRegex(@"^\s*((?<seasonnumber>(?>\d+))(?:st|nd|rd|th|\.)*(?!\s*[Ee]\d+))\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
         private static partial Regex ProcessPre();
 
-        [GeneratedRegex(@"^\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<seasonnumber>(?>\d+)(?!\s*[Ee]\d+))(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
+        [GeneratedRegex(@"^\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<seasonnumber>\d+?)(?=\d{3,4}p|[^\d]|$)(?!\s*[Ee]\d)(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
         private static partial Regex ProcessPost();
 
+        [GeneratedRegex(@"[sS](\d{1,4})(?!\d|[eE]\d)(?=\.|_|-|\[|\]|\s|$)", RegexOptions.None)]
+        private static partial Regex SeasonPrefix();
+
         /// <summary>
         /// Attempts to parse season number from path.
         /// </summary>
@@ -56,44 +61,34 @@ namespace Emby.Naming.TV
             bool supportSpecialAliases,
             bool supportNumericSeasonFolders)
         {
-            string filename = Path.GetFileName(path);
-            filename = Regex.Replace(filename, "[ ._-]", string.Empty);
+            var fileName = Path.GetFileName(path);
 
-            if (parentFolderName is not null)
+            var seasonPrefixMatch = SeasonPrefix().Match(fileName);
+            if (seasonPrefixMatch.Success &&
+                int.TryParse(seasonPrefixMatch.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var val))
             {
-                parentFolderName = Regex.Replace(parentFolderName, "[ ._-]", string.Empty);
-                filename = filename.Replace(parentFolderName, string.Empty, StringComparison.OrdinalIgnoreCase);
+                return (val, true);
             }
 
-            if (supportSpecialAliases)
-            {
-                if (string.Equals(filename, "specials", StringComparison.OrdinalIgnoreCase))
-                {
-                    return (0, true);
-                }
+            string filename = CleanNameRegex.Replace(fileName, string.Empty);
 
-                if (string.Equals(filename, "extras", StringComparison.OrdinalIgnoreCase))
-                {
-                    return (0, true);
-                }
+            if (parentFolderName is not null)
+            {
+                var cleanParent = CleanNameRegex.Replace(parentFolderName, string.Empty);
+                filename = filename.Replace(cleanParent, string.Empty, StringComparison.OrdinalIgnoreCase);
             }
 
-            if (supportNumericSeasonFolders)
+            if (supportSpecialAliases &&
+                (filename.Equals("specials", StringComparison.OrdinalIgnoreCase) ||
+                 filename.Equals("extras", StringComparison.OrdinalIgnoreCase)))
             {
-                if (int.TryParse(filename, NumberStyles.Integer, CultureInfo.InvariantCulture, out var val))
-                {
-                    return (val, true);
-                }
+                return (0, true);
             }
 
-            if (filename.Length > 0 && (filename[0] == 'S' || filename[0] == 's'))
+            if (supportNumericSeasonFolders &&
+                int.TryParse(filename, NumberStyles.Integer, CultureInfo.InvariantCulture, out val))
             {
-                var testFilename = filename.AsSpan()[1..];
-
-                if (int.TryParse(testFilename, NumberStyles.Integer, CultureInfo.InvariantCulture, out var val))
-                {
-                    return (val, true);
-                }
+                return (val, true);
             }
 
             var preMatch = ProcessPre().Match(filename);
diff --git a/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs b/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
index 0c3671f4f..4dbe769bf 100644
--- a/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
+++ b/tests/Jellyfin.Naming.Tests/TV/SeasonPathParserTests.cs
@@ -69,6 +69,12 @@ public class SeasonPathParserTests
     [InlineData("/media/YouTube/Devyn Johnston/2024-01-24 4070 Ti SUPER in under 7 minutes", "/media/YouTube/Devyn Johnston", null, false)]
     [InlineData("/media/YouTube/Devyn Johnston/2025-01-28 5090 vs 2 SFF Cases", "/media/YouTube/Devyn Johnston", null, false)]
     [InlineData("/Drive/202401244070", "/Drive", null, false)]
+    [InlineData("/Drive/Drive.S01.2160p.WEB-DL.DDP5.1.H.265-XXXX", "/Drive", 1, true)]
+    [InlineData("The Wonder Years/The.Wonder.Years.S04.1080p.PDTV.x264-JCH", "/The Wonder Years", 4, true)]
+    [InlineData("The Wonder Years/[The.Wonder.Years.S04.1080p.PDTV.x264-JCH]", "/The Wonder Years", 4, true)]
+    [InlineData("The Wonder Years/The.Wonder.Years [S04][1080p.PDTV.x264-JCH]", "/The Wonder Years", 4, true)]
+    [InlineData("The Wonder Years/The Wonder Years Season 01 1080p", "/The Wonder Years", 1, true)]
+
     public void GetSeasonNumberFromPathTest(string path, string? parentPath, int? seasonNumber, bool isSeasonDirectory)
     {
         var result = SeasonPathParser.Parse(path, parentPath, true, true);
-- 
cgit v1.2.3


From 74c9629372b9347f9e53fcb549488d2df4c969b9 Mon Sep 17 00:00:00 2001
From: JPVenson <github@jpb.email>
Date: Mon, 17 Nov 2025 14:08:55 -0500
Subject: Backport pull request #15413 from jellyfin/release-10.11.z

Fixed missing sort argument

Original-merge: 91c3b1617e06283c88f36bc63046b99c993cb774

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Bond_009 <bond.009@outlook.com>
---
 .../Item/BaseItemRepository.cs                     | 17 ++---
 .../Item/OrderMapper.cs                            | 72 +++++++++++++---------
 .../Item/OrderMapperTests.cs                       |  2 +-
 3 files changed, 54 insertions(+), 37 deletions(-)

(limited to 'tests')

diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 06fb8ec21..060705f74 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -275,6 +275,7 @@ public sealed class BaseItemRepository
         }
 
         dbQuery = ApplyQueryPaging(dbQuery, filter);
+        dbQuery = ApplyNavigations(dbQuery, filter);
 
         result.Items = dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).ToArray();
         result.StartIndex = filter.StartIndex ?? 0;
@@ -294,6 +295,7 @@ public sealed class BaseItemRepository
 
         dbQuery = ApplyGroupingFilter(context, dbQuery, filter);
         dbQuery = ApplyQueryPaging(dbQuery, filter);
+        dbQuery = ApplyNavigations(dbQuery, filter);
 
         return dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).ToArray();
     }
@@ -337,6 +339,8 @@ public sealed class BaseItemRepository
         mainquery = ApplyGroupingFilter(context, mainquery, filter);
         mainquery = ApplyQueryPaging(mainquery, filter);
 
+        mainquery = ApplyNavigations(mainquery, filter);
+
         return mainquery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).ToArray();
     }
 
@@ -399,9 +403,7 @@ public sealed class BaseItemRepository
             dbQuery = dbQuery.Distinct();
         }
 
-        dbQuery = ApplyOrder(dbQuery, filter);
-
-        dbQuery = ApplyNavigations(dbQuery, filter);
+        dbQuery = ApplyOrder(dbQuery, filter, context);
 
         return dbQuery;
     }
@@ -446,6 +448,7 @@ public sealed class BaseItemRepository
         dbQuery = TranslateQuery(dbQuery, context, filter);
         dbQuery = ApplyGroupingFilter(context, dbQuery, filter);
         dbQuery = ApplyQueryPaging(dbQuery, filter);
+        dbQuery = ApplyNavigations(dbQuery, filter);
         return dbQuery;
     }
 
@@ -1252,7 +1255,7 @@ public sealed class BaseItemRepository
             .AsSingleQuery()
             .Where(e => masterQuery.Contains(e.Id));
 
-        query = ApplyOrder(query, filter);
+        query = ApplyOrder(query, filter, context);
 
         var result = new QueryResult<(BaseItemDto, ItemCounts?)>();
         if (filter.EnableTotalRecordCount)
@@ -1518,7 +1521,7 @@ public sealed class BaseItemRepository
             || query.IncludeItemTypes.Contains(BaseItemKind.Season);
     }
 
-    private IQueryable<BaseItemEntity> ApplyOrder(IQueryable<BaseItemEntity> query, InternalItemsQuery filter)
+    private IQueryable<BaseItemEntity> ApplyOrder(IQueryable<BaseItemEntity> query, InternalItemsQuery filter, JellyfinDbContext context)
     {
         var orderBy = filter.OrderBy;
         var hasSearch = !string.IsNullOrEmpty(filter.SearchTerm);
@@ -1537,7 +1540,7 @@ public sealed class BaseItemRepository
         var firstOrdering = orderBy.FirstOrDefault();
         if (firstOrdering != default)
         {
-            var expression = OrderMapper.MapOrderByField(firstOrdering.OrderBy, filter);
+            var expression = OrderMapper.MapOrderByField(firstOrdering.OrderBy, filter, context);
             if (firstOrdering.SortOrder == SortOrder.Ascending)
             {
                 orderedQuery = query.OrderBy(expression);
@@ -1562,7 +1565,7 @@ public sealed class BaseItemRepository
 
         foreach (var item in orderBy.Skip(1))
         {
-            var expression = OrderMapper.MapOrderByField(item.OrderBy, filter);
+            var expression = OrderMapper.MapOrderByField(item.OrderBy, filter, context);
             if (item.SortOrder == SortOrder.Ascending)
             {
                 orderedQuery = orderedQuery!.ThenBy(expression);
diff --git a/Jellyfin.Server.Implementations/Item/OrderMapper.cs b/Jellyfin.Server.Implementations/Item/OrderMapper.cs
index a0c127031..192ee7499 100644
--- a/Jellyfin.Server.Implementations/Item/OrderMapper.cs
+++ b/Jellyfin.Server.Implementations/Item/OrderMapper.cs
@@ -1,7 +1,10 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+
 using System;
 using System.Linq;
 using System.Linq.Expressions;
 using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
 using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Controller.Entities;
 using Microsoft.EntityFrameworkCore;
@@ -18,39 +21,50 @@ public static class OrderMapper
     /// </summary>
     /// <param name="sortBy">Item property to sort by.</param>
     /// <param name="query">Context Query.</param>
+    /// <param name="jellyfinDbContext">Context.</param>
     /// <returns>Func to be executed later for sorting query.</returns>
-    public static Expression<Func<BaseItemEntity, object?>> MapOrderByField(ItemSortBy sortBy, InternalItemsQuery query)
+    public static Expression<Func<BaseItemEntity, object?>> MapOrderByField(ItemSortBy sortBy, InternalItemsQuery query, JellyfinDbContext jellyfinDbContext)
     {
-        return sortBy switch
+        return (sortBy, query.User) switch
         {
-            ItemSortBy.AirTime => e => e.SortName, // TODO
-            ItemSortBy.Runtime => e => e.RunTimeTicks,
-            ItemSortBy.Random => e => EF.Functions.Random(),
-            ItemSortBy.DatePlayed => e => e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.LastPlayedDate,
-            ItemSortBy.PlayCount => e => e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.PlayCount,
-            ItemSortBy.IsFavoriteOrLiked => e => e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.IsFavorite,
-            ItemSortBy.IsFolder => e => e.IsFolder,
-            ItemSortBy.IsPlayed => e => e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.Played,
-            ItemSortBy.IsUnplayed => e => !e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.Played,
-            ItemSortBy.DateLastContentAdded => e => e.DateLastMediaAdded,
-            ItemSortBy.Artist => e => e.ItemValues!.Where(f => f.ItemValue.Type == ItemValueType.Artist).Select(f => f.ItemValue.CleanValue).FirstOrDefault(),
-            ItemSortBy.AlbumArtist => e => e.ItemValues!.Where(f => f.ItemValue.Type == ItemValueType.AlbumArtist).Select(f => f.ItemValue.CleanValue).FirstOrDefault(),
-            ItemSortBy.Studio => e => e.ItemValues!.Where(f => f.ItemValue.Type == ItemValueType.Studios).Select(f => f.ItemValue.CleanValue).FirstOrDefault(),
-            ItemSortBy.OfficialRating => e => e.InheritedParentalRatingValue,
-            // ItemSortBy.SeriesDatePlayed => "(Select MAX(LastPlayedDate) from TypedBaseItems B" + GetJoinUserDataText(query) + " where Played=1 and B.SeriesPresentationUniqueKey=A.PresentationUniqueKey)",
-            ItemSortBy.SeriesSortName => e => e.SeriesName,
+            (ItemSortBy.AirTime, _) => e => e.SortName, // TODO
+            (ItemSortBy.Runtime, _) => e => e.RunTimeTicks,
+            (ItemSortBy.Random, _) => e => EF.Functions.Random(),
+            (ItemSortBy.DatePlayed, _) => e => e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.LastPlayedDate,
+            (ItemSortBy.PlayCount, _) => e => e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.PlayCount,
+            (ItemSortBy.IsFavoriteOrLiked, _) => e => e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.IsFavorite,
+            (ItemSortBy.IsFolder, _) => e => e.IsFolder,
+            (ItemSortBy.IsPlayed, _) => e => e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.Played,
+            (ItemSortBy.IsUnplayed, _) => e => !e.UserData!.FirstOrDefault(f => f.UserId.Equals(query.User!.Id))!.Played,
+            (ItemSortBy.DateLastContentAdded, _) => e => e.DateLastMediaAdded,
+            (ItemSortBy.Artist, _) => e => e.ItemValues!.Where(f => f.ItemValue.Type == ItemValueType.Artist).Select(f => f.ItemValue.CleanValue).FirstOrDefault(),
+            (ItemSortBy.AlbumArtist, _) => e => e.ItemValues!.Where(f => f.ItemValue.Type == ItemValueType.AlbumArtist).Select(f => f.ItemValue.CleanValue).FirstOrDefault(),
+            (ItemSortBy.Studio, _) => e => e.ItemValues!.Where(f => f.ItemValue.Type == ItemValueType.Studios).Select(f => f.ItemValue.CleanValue).FirstOrDefault(),
+            (ItemSortBy.OfficialRating, _) => e => e.InheritedParentalRatingValue,
+            (ItemSortBy.SeriesSortName, _) => e => e.SeriesName,
+            (ItemSortBy.Album, _) => e => e.Album,
+            (ItemSortBy.DateCreated, _) => e => e.DateCreated,
+            (ItemSortBy.PremiereDate, _) => e => (e.PremiereDate ?? (e.ProductionYear.HasValue ? DateTime.MinValue.AddYears(e.ProductionYear.Value - 1) : null)),
+            (ItemSortBy.StartDate, _) => e => e.StartDate,
+            (ItemSortBy.Name, _) => e => e.CleanName,
+            (ItemSortBy.CommunityRating, _) => e => e.CommunityRating,
+            (ItemSortBy.ProductionYear, _) => e => e.ProductionYear,
+            (ItemSortBy.CriticRating, _) => e => e.CriticRating,
+            (ItemSortBy.VideoBitRate, _) => e => e.TotalBitrate,
+            (ItemSortBy.ParentIndexNumber, _) => e => e.ParentIndexNumber,
+            (ItemSortBy.IndexNumber, _) => e => e.IndexNumber,
+            (ItemSortBy.SeriesDatePlayed, not null) => e =>
+                            jellyfinDbContext.BaseItems
+                                .Where(w => w.SeriesPresentationUniqueKey == e.PresentationUniqueKey)
+                                .Join(jellyfinDbContext.UserData.Where(w => w.UserId == query.User.Id && w.Played), f => f.Id, f => f.ItemId, (item, userData) => userData.LastPlayedDate)
+                                .Max(f => f),
+            (ItemSortBy.SeriesDatePlayed, null) => e => jellyfinDbContext.BaseItems.Where(w => w.SeriesPresentationUniqueKey == e.PresentationUniqueKey)
+                                .Join(jellyfinDbContext.UserData.Where(w => w.Played), f => f.Id, f => f.ItemId, (item, userData) => userData.LastPlayedDate)
+                                .Max(f => f),
+            // ItemSortBy.SeriesDatePlayed => e => jellyfinDbContext.UserData
+            //     .Where(u => u.Item!.SeriesPresentationUniqueKey == e.PresentationUniqueKey && u.Played)
+            //     .Max(f => f.LastPlayedDate),
             // ItemSortBy.AiredEpisodeOrder => "AiredEpisodeOrder",
-            ItemSortBy.Album => e => e.Album,
-            ItemSortBy.DateCreated => e => e.DateCreated,
-            ItemSortBy.PremiereDate => e => (e.PremiereDate ?? (e.ProductionYear.HasValue ? DateTime.MinValue.AddYears(e.ProductionYear.Value - 1) : null)),
-            ItemSortBy.StartDate => e => e.StartDate,
-            ItemSortBy.Name => e => e.CleanName,
-            ItemSortBy.CommunityRating => e => e.CommunityRating,
-            ItemSortBy.ProductionYear => e => e.ProductionYear,
-            ItemSortBy.CriticRating => e => e.CriticRating,
-            ItemSortBy.VideoBitRate => e => e.TotalBitrate,
-            ItemSortBy.ParentIndexNumber => e => e.ParentIndexNumber,
-            ItemSortBy.IndexNumber => e => e.IndexNumber,
             _ => e => e.SortName
         };
     }
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs
index caf2b06b7..8ac3e5e31 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs
@@ -12,7 +12,7 @@ public class OrderMapperTests
     [Fact]
     public void ShouldReturnMappedOrderForSortingByPremierDate()
     {
-        var orderFunc = OrderMapper.MapOrderByField(ItemSortBy.PremiereDate, new InternalItemsQuery()).Compile();
+        var orderFunc = OrderMapper.MapOrderByField(ItemSortBy.PremiereDate, new InternalItemsQuery(), null!).Compile();
 
         var expectedDate = new DateTime(1, 2, 3);
         var expectedProductionYearDate = new DateTime(4, 1, 1);
-- 
cgit v1.2.3


From 8fd59d6f336a95782a13b0440a6cf5108e58a1f8 Mon Sep 17 00:00:00 2001
From: audrey-inglish <112636119+audrey-inglish@users.noreply.github.com>
Date: Mon, 8 Dec 2025 10:43:37 -0700
Subject: Merge pull request #14879 from audrey-inglish/master

Fix: normalize punctuation when computing CleanName so searches without punctuation match (closes #1674)
---
 .../Item/BaseItemRepository.cs                     |  44 ++++++++-
 .../Migrations/Routines/RefreshCleanNames.cs       | 105 ++++++++++++++++++++
 .../Data/SearchPunctuationTests.cs                 | 109 +++++++++++++++++++++
 3 files changed, 256 insertions(+), 2 deletions(-)
 create mode 100644 Jellyfin.Server/Migrations/Routines/RefreshCleanNames.cs
 create mode 100644 tests/Jellyfin.Server.Implementations.Tests/Data/SearchPunctuationTests.cs

(limited to 'tests')

diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 84168291a..57d874e59 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -1373,14 +1373,54 @@ public sealed class BaseItemRepository
         }
     }
 
-    private string GetCleanValue(string value)
+    /// <summary>
+    /// Gets the clean value for search and sorting purposes.
+    /// </summary>
+    /// <param name="value">The value to clean.</param>
+    /// <returns>The cleaned value.</returns>
+    public static string GetCleanValue(string value)
     {
         if (string.IsNullOrWhiteSpace(value))
         {
             return value;
         }
 
-        return value.RemoveDiacritics().ToLowerInvariant();
+        var noDiacritics = value.RemoveDiacritics();
+
+        // Build a string where any punctuation or symbol is treated as a separator (space).
+        var sb = new StringBuilder(noDiacritics.Length);
+        var previousWasSpace = false;
+        foreach (var ch in noDiacritics)
+        {
+            char outCh;
+            if (char.IsLetterOrDigit(ch) || char.IsWhiteSpace(ch))
+            {
+                outCh = ch;
+            }
+            else
+            {
+                outCh = ' ';
+            }
+
+            // normalize any whitespace character to a single ASCII space.
+            if (char.IsWhiteSpace(outCh))
+            {
+                if (!previousWasSpace)
+                {
+                    sb.Append(' ');
+                    previousWasSpace = true;
+                }
+            }
+            else
+            {
+                sb.Append(outCh);
+                previousWasSpace = false;
+            }
+        }
+
+        // trim leading/trailing spaces that may have been added.
+        var collapsed = sb.ToString().Trim();
+        return collapsed.ToLowerInvariant();
     }
 
     private List<(ItemValueType MagicNumber, string Value)> GetItemValuesToSave(BaseItemDto item, List<string> inheritedTags)
diff --git a/Jellyfin.Server/Migrations/Routines/RefreshCleanNames.cs b/Jellyfin.Server/Migrations/Routines/RefreshCleanNames.cs
new file mode 100644
index 000000000..eadabf677
--- /dev/null
+++ b/Jellyfin.Server/Migrations/Routines/RefreshCleanNames.cs
@@ -0,0 +1,105 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using Jellyfin.Server.Implementations.Item;
+using Jellyfin.Server.ServerSetupApp;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Jellyfin.Server.Migrations.Routines;
+
+/// <summary>
+/// Migration to refresh CleanName values for all library items.
+/// </summary>
+[JellyfinMigration("2025-10-08T12:00:00", nameof(RefreshCleanNames))]
+[JellyfinMigrationBackup(JellyfinDb = true)]
+public class RefreshCleanNames : IAsyncMigrationRoutine
+{
+    private readonly IStartupLogger<RefreshCleanNames> _logger;
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="RefreshCleanNames"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="dbProvider">Instance of the <see cref="IDbContextFactory{JellyfinDbContext}"/> interface.</param>
+    public RefreshCleanNames(
+        IStartupLogger<RefreshCleanNames> logger,
+        IDbContextFactory<JellyfinDbContext> dbProvider)
+    {
+        _logger = logger;
+        _dbProvider = dbProvider;
+    }
+
+    /// <inheritdoc />
+    public async Task PerformAsync(CancellationToken cancellationToken)
+    {
+        const int Limit = 1000;
+        int itemCount = 0;
+
+        var sw = Stopwatch.StartNew();
+
+        using var context = _dbProvider.CreateDbContext();
+        var records = context.BaseItems.Count(b => !string.IsNullOrEmpty(b.Name));
+        _logger.LogInformation("Refreshing CleanName for {Count} library items", records);
+
+        var processedInPartition = 0;
+
+        await foreach (var item in context.BaseItems
+                          .Where(b => !string.IsNullOrEmpty(b.Name))
+                          .OrderBy(e => e.Id)
+                          .WithPartitionProgress((partition) => _logger.LogInformation("Processed: {Offset}/{Total} - Updated: {UpdatedCount} - Time: {Elapsed}", partition * Limit, records, itemCount, sw.Elapsed))
+                          .PartitionEagerAsync(Limit, cancellationToken)
+                          .WithCancellation(cancellationToken)
+                          .ConfigureAwait(false))
+        {
+            try
+            {
+                var newCleanName = string.IsNullOrWhiteSpace(item.Name) ? string.Empty : BaseItemRepository.GetCleanValue(item.Name);
+                if (!string.Equals(newCleanName, item.CleanName, StringComparison.Ordinal))
+                {
+                    _logger.LogDebug(
+                        "Updating CleanName for item {Id}: '{OldValue}' -> '{NewValue}'",
+                        item.Id,
+                        item.CleanName,
+                        newCleanName);
+                    item.CleanName = newCleanName;
+                    itemCount++;
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to update CleanName for item {Id} ({Name})", item.Id, item.Name);
+            }
+
+            processedInPartition++;
+
+            if (processedInPartition >= Limit)
+            {
+                await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+                // Clear tracked entities to avoid memory growth across partitions
+                context.ChangeTracker.Clear();
+                processedInPartition = 0;
+            }
+        }
+
+        // Save any remaining changes after the loop
+        if (processedInPartition > 0)
+        {
+            await context.SaveChangesAsync(cancellationToken).ConfigureAwait(false);
+            context.ChangeTracker.Clear();
+        }
+
+        _logger.LogInformation(
+            "Refreshed CleanName for {UpdatedCount} out of {TotalCount} items in {Time}",
+            itemCount,
+            records,
+            sw.Elapsed);
+    }
+}
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Data/SearchPunctuationTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Data/SearchPunctuationTests.cs
new file mode 100644
index 000000000..8fbccd801
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Data/SearchPunctuationTests.cs
@@ -0,0 +1,109 @@
+using System;
+using AutoFixture;
+using AutoFixture.AutoMoq;
+using Jellyfin.Server.Implementations.Item;
+using MediaBrowser.Controller.Entities.TV;
+using Microsoft.Extensions.Configuration;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Data
+{
+    public class SearchPunctuationTests
+    {
+        private readonly IFixture _fixture;
+        private readonly BaseItemRepository _repo;
+
+        public SearchPunctuationTests()
+        {
+            var appHost = new Mock<MediaBrowser.Controller.IServerApplicationHost>();
+            appHost.Setup(x => x.ExpandVirtualPath(It.IsAny<string>()))
+                .Returns((string x) => x);
+            appHost.Setup(x => x.ReverseVirtualPath(It.IsAny<string>()))
+                .Returns((string x) => x);
+
+            var configSection = new Mock<IConfigurationSection>();
+            configSection
+                .SetupGet(x => x[It.Is<string>(s => s == MediaBrowser.Controller.Extensions.ConfigurationExtensions.SqliteCacheSizeKey)])
+                .Returns("0");
+            var config = new Mock<IConfiguration>();
+            config
+                .Setup(x => x.GetSection(It.Is<string>(s => s == MediaBrowser.Controller.Extensions.ConfigurationExtensions.SqliteCacheSizeKey)))
+                .Returns(configSection.Object);
+
+            _fixture = new Fixture().Customize(new AutoMoqCustomization { ConfigureMembers = true });
+            _fixture.Inject(appHost.Object);
+            _fixture.Inject(config.Object);
+
+            _repo = _fixture.Create<BaseItemRepository>();
+        }
+
+        [Fact]
+        public void CleanName_keeps_punctuation_and_search_without_punctuation_passes()
+        {
+            var series = new Series
+            {
+                Id = Guid.NewGuid(),
+                Name = "Mr. Robot"
+            };
+
+            series.SortName = "Mr. Robot";
+
+            var entity = _repo.Map(series);
+            Assert.Equal("mr robot", entity.CleanName);
+
+            var searchTerm = "Mr Robot".ToLowerInvariant();
+
+            Assert.Contains(searchTerm, entity.CleanName ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        }
+
+        [Theory]
+        [InlineData("Spider-Man: Homecoming", "spider man homecoming")]
+        [InlineData("Beyoncé — Live!", "beyonce live")]
+        [InlineData("Hello, World!", "hello world")]
+        [InlineData("(The) Good, the Bad & the Ugly", "the good the bad the ugly")]
+        [InlineData("Wall-E", "wall e")]
+        [InlineData("No. 1: The Beginning", "no 1 the beginning")]
+        [InlineData("Café-au-lait", "cafe au lait")]
+        public void CleanName_normalizes_various_punctuation(string title, string expectedClean)
+        {
+            var series = new Series
+            {
+                Id = Guid.NewGuid(),
+                Name = title
+            };
+
+            series.SortName = title;
+
+            var entity = _repo.Map(series);
+
+            Assert.Equal(expectedClean, entity.CleanName);
+
+            // Ensure a search term without punctuation would match
+            var searchTerm = expectedClean;
+            Assert.Contains(searchTerm, entity.CleanName ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        }
+
+        [Theory]
+        [InlineData("Face/Off", "face off")]
+        [InlineData("V/H/S", "v h s")]
+        public void CleanName_normalizes_titles_withslashes(string title, string expectedClean)
+        {
+            var series = new Series
+            {
+                Id = Guid.NewGuid(),
+                Name = title
+            };
+
+            series.SortName = title;
+
+            var entity = _repo.Map(series);
+
+            Assert.Equal(expectedClean, entity.CleanName);
+
+            // Ensure a search term without punctuation would match
+            var searchTerm = expectedClean;
+            Assert.Contains(searchTerm, entity.CleanName ?? string.Empty, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+}
-- 
cgit v1.2.3


From acb9da6f93829eaef356d3effd1872798c778adb Mon Sep 17 00:00:00 2001
From: Nilesh Patel <nileshp@nilesh.io>
Date: Wed, 10 Dec 2025 12:23:05 -0800
Subject: Add curly brace and parentheses support for parsing attribute values
 from paths

---
 .../Library/PathExtensions.cs                      | 24 +++++++++++++++-------
 .../Library/PathExtensionsTests.cs                 | 19 +++++++++++++----
 2 files changed, 32 insertions(+), 11 deletions(-)

(limited to 'tests')

diff --git a/Emby.Server.Implementations/Library/PathExtensions.cs b/Emby.Server.Implementations/Library/PathExtensions.cs
index 21e7079d8..fc63251ad 100644
--- a/Emby.Server.Implementations/Library/PathExtensions.cs
+++ b/Emby.Server.Implementations/Library/PathExtensions.cs
@@ -37,15 +37,25 @@ namespace Emby.Server.Implementations.Library
             while (attributeIndex > -1 && attributeIndex < maxIndex)
             {
                 var attributeEnd = attributeIndex + attribute.Length;
-                if (attributeIndex > 0
-                    && str[attributeIndex - 1] == '['
-                    && (str[attributeEnd] == '=' || str[attributeEnd] == '-'))
+                if (attributeIndex > 0)
                 {
-                    var closingIndex = str[attributeEnd..].IndexOf(']');
-                    // Must be at least 1 character before the closing bracket.
-                    if (closingIndex > 1)
+                    var attributeOpener = str[attributeIndex - 1];
+                    var attributeCloser = attributeOpener switch
                     {
-                        return str[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim().ToString();
+                        '[' => ']',
+                        '(' => ')',
+                        '{' => '}',
+                         _ => '\0'
+                    };
+                    if (attributeCloser != '\0' && (str[attributeEnd] == '=' || str[attributeEnd] == '-'))
+                    {
+                        var closingIndex = str[attributeEnd..].IndexOf(attributeCloser);
+
+                        // Must be at least 1 character before the closing bracket.
+                        if (closingIndex > 1)
+                        {
+                            return str[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim().ToString();
+                        }
                     }
                 }
 
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
index 940e3c2b1..74cd303ba 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
@@ -11,21 +11,29 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("Superman: Red Son [imdbid=tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son [imdbid-tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son - tt10985510", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son {imdbid=tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (imdbid-tt10985510)", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son", "imdbid", null)]
-        [InlineData("Superman: Red Son", "something", null)]
         [InlineData("Superman: Red Son [imdbid1=tt11111111][imdbid=tt10985510]", "imdbid", "tt10985510")]
-        [InlineData("Superman: Red Son [imdbid1-tt11111111][imdbid=tt10985510]", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son {imdbid1=tt11111111}(imdbid=tt10985510)", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (imdbid1-tt11111111)[imdbid=tt10985510]", "imdbid", "tt10985510")]
         [InlineData("Superman: Red Son [tmdbid=618355][imdbid=tt10985510]", "imdbid", "tt10985510")]
-        [InlineData("Superman: Red Son [tmdbid-618355][imdbid-tt10985510]", "imdbid", "tt10985510")]
-        [InlineData("Superman: Red Son [tmdbid-618355][imdbid-tt10985510]", "tmdbid", "618355")]
+        [InlineData("Superman: Red Son [tmdbid-618355]{imdbid-tt10985510}", "imdbid", "tt10985510")]
+        [InlineData("Superman: Red Son (tmdbid-618355)[imdbid-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 [tmdbid=3]", "tmdbid", "3")]
         [InlineData("Superman: Red Son [tvdbid-6]", "tvdbid", "6")]
+        [InlineData("Superman: Red Son {tmdbid=3)", "tmdbid", "3")]
+        [InlineData("Superman: Red Son (tvdbid-6}", "tvdbid", "6")]
         [InlineData("[tmdbid=618355]", "tmdbid", "618355")]
+        [InlineData("{tmdbid=618355}", "tmdbid", "618355")]
+        [InlineData("(tmdbid=618355)", "tmdbid", "618355")]
         [InlineData("[tmdbid-618355]", "tmdbid", "618355")]
+        [InlineData("{tmdbid-618355)", "tmdbid", null)]
+        [InlineData("[tmdbid-618355}", "tmdbid", null)]
         [InlineData("tmdbid=111111][tmdbid=618355]", "tmdbid", "618355")]
         [InlineData("[tmdbid=618355]tmdbid=111111]", "tmdbid", "618355")]
         [InlineData("tmdbid=618355]", "tmdbid", null)]
@@ -36,6 +44,9 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("[tmdbid=][imdbid=tt10985510]", "tmdbid", null)]
         [InlineData("[tmdbid-][imdbid-tt10985510]", "tmdbid", null)]
         [InlineData("Superman: Red Son [tmdbid-618355][tmdbid=1234567]", "tmdbid", "618355")]
+        [InlineData("{tmdbid=}{imdbid=tt10985510}", "tmdbid", null)]
+        [InlineData("(tmdbid-)(imdbid-tt10985510)", "tmdbid", null)]
+        [InlineData("Superman: Red Son {tmdbid-618355}{tmdbid=1234567}", "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 b9cf26db2f3d219340a17951c289a230d0ccf31a Mon Sep 17 00:00:00 2001
From: Shadowghost <Shadowghost@users.noreply.github.com>
Date: Sun, 28 Dec 2025 07:22:20 -0500
Subject: Backport pull request #15746 from jellyfin/release-10.11.z

Skip invalid ignore rules

Original-merge: 6e60634c9f078cc01e343b07a0a6b2a5c230478c

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Bond_009 <bond.009@outlook.com>
---
 .../Library/DotIgnoreIgnoreRule.cs                 | 48 +++++++++++-
 .../Library/DotIgnoreIgnoreRuleTest.cs             | 87 +++++++++++++++++-----
 2 files changed, 115 insertions(+), 20 deletions(-)

(limited to 'tests')

diff --git a/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs b/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs
index 473ff8e1d..ef5d24c70 100644
--- a/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs
+++ b/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs
@@ -1,5 +1,6 @@
 using System;
 using System.IO;
+using System.Text.RegularExpressions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Resolvers;
@@ -70,12 +71,55 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
     {
         // If file has content, base ignoring off the content .gitignore-style rules
         var rules = ignoreFileContent.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        return CheckIgnoreRules(path, rules, isDirectory);
+    }
+
+    /// <summary>
+    /// Checks whether a path should be ignored based on an array of ignore rules.
+    /// </summary>
+    /// <param name="path">The path to check.</param>
+    /// <param name="rules">The array of ignore rules.</param>
+    /// <param name="isDirectory">Whether the path is a directory.</param>
+    /// <returns>True if the path should be ignored.</returns>
+    internal static bool CheckIgnoreRules(string path, string[] rules, bool isDirectory)
+        => CheckIgnoreRules(path, rules, isDirectory, IsWindows);
+
+    /// <summary>
+    /// Checks whether a path should be ignored based on an array of ignore rules.
+    /// </summary>
+    /// <param name="path">The path to check.</param>
+    /// <param name="rules">The array of ignore rules.</param>
+    /// <param name="isDirectory">Whether the path is a directory.</param>
+    /// <param name="normalizePath">Whether to normalize backslashes to forward slashes (for Windows paths).</param>
+    /// <returns>True if the path should be ignored.</returns>
+    internal static bool CheckIgnoreRules(string path, string[] rules, bool isDirectory, bool normalizePath)
+    {
         var ignore = new Ignore.Ignore();
-        ignore.Add(rules);
+
+        // Add each rule individually to catch and skip invalid patterns
+        var validRulesAdded = 0;
+        foreach (var rule in rules)
+        {
+            try
+            {
+                ignore.Add(rule);
+                validRulesAdded++;
+            }
+            catch (RegexParseException)
+            {
+                // Ignore invalid patterns
+            }
+        }
+
+        // If no valid rules were added, fall back to ignoring everything (like an empty .ignore file)
+        if (validRulesAdded == 0)
+        {
+            return true;
+        }
 
          // Mitigate the problem of the Ignore library not handling Windows paths correctly.
          // See https://github.com/jellyfin/jellyfin/issues/15484
-        var pathToCheck = IsWindows ? path.NormalizePath('/') : path;
+        var pathToCheck = normalizePath ? path.NormalizePath('/') : path;
 
         // Add trailing slash for directories to match "folder/"
         if (isDirectory)
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
index d677c9f09..a7bbef7ed 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/DotIgnoreIgnoreRuleTest.cs
@@ -1,30 +1,81 @@
+using Emby.Server.Implementations.Library;
 using Xunit;
 
 namespace Jellyfin.Server.Implementations.Tests.Library;
 
 public class DotIgnoreIgnoreRuleTest
 {
-    [Fact]
-    public void Test()
+    private static readonly string[] _rule1 = ["SPs"];
+    private static readonly string[] _rule2 = ["SPs", "!thebestshot.mkv"];
+    private static readonly string[] _rule3 = ["*.txt", @"{\colortbl;\red255\green255\blue255;}", "videos/", @"\invalid\escape\sequence", "*.mkv"];
+    private static readonly string[] _rule4 = [@"{\colortbl;\red255\green255\blue255;}", @"\invalid\escape\sequence"];
+
+    public static TheoryData<string[], string, bool, bool> CheckIgnoreRulesTestData =>
+        new()
+        {
+            // Basic pattern matching
+            { _rule1, "f:/cd/sps/ffffff.mkv", false, true },
+            { _rule1, "cd/sps/ffffff.mkv", false, true },
+            { _rule1, "/cd/sps/ffffff.mkv", false, true },
+
+            // Negate pattern
+            { _rule2, "f:/cd/sps/ffffff.mkv", false, true },
+            { _rule2, "cd/sps/ffffff.mkv", false, true },
+            { _rule2, "/cd/sps/ffffff.mkv", false, true },
+            { _rule2, "f:/cd/sps/thebestshot.mkv", false, false },
+            { _rule2, "cd/sps/thebestshot.mkv", false, false },
+            { _rule2, "/cd/sps/thebestshot.mkv", false, false },
+
+            // Mixed valid and invalid patterns - skips invalid, applies valid
+            { _rule3, "test.txt", false, true },
+            { _rule3, "videos/movie.mp4", false, true },
+            { _rule3, "movie.mkv", false, true },
+            { _rule3, "test.mp3", false, false },
+
+            // Only invalid patterns - falls back to ignore all
+            { _rule4, "any-file.txt", false, true },
+            { _rule4, "any/path/to/file.mkv", false, true },
+        };
+
+    public static TheoryData<string[], string, bool, bool> WindowsPathNormalizationTestData =>
+        new()
+        {
+            // Windows paths with backslashes - should match when normalizePath is true
+            { _rule1, @"C:\cd\sps\ffffff.mkv", false, true },
+            { _rule1, @"D:\media\sps\movie.mkv", false, true },
+            { _rule1, @"\\server\share\sps\file.mkv", false, true },
+
+            // Negate pattern with Windows paths
+            { _rule2, @"C:\cd\sps\ffffff.mkv", false, true },
+            { _rule2, @"C:\cd\sps\thebestshot.mkv", false, false },
+
+            // Directory matching with Windows paths
+            { _rule3, @"C:\videos\movie.mp4", false, true },
+            { _rule3, @"D:\documents\test.txt", false, true },
+            { _rule3, @"E:\music\song.mp3", false, false },
+        };
+
+    [Theory]
+    [MemberData(nameof(CheckIgnoreRulesTestData))]
+    public void CheckIgnoreRules_ReturnsExpectedResult(string[] rules, string path, bool isDirectory, bool expectedIgnored)
+    {
+        Assert.Equal(expectedIgnored, DotIgnoreIgnoreRule.CheckIgnoreRules(path, rules, isDirectory));
+    }
+
+    [Theory]
+    [MemberData(nameof(WindowsPathNormalizationTestData))]
+    public void CheckIgnoreRules_WithWindowsPaths_NormalizesBackslashes(string[] rules, string path, bool isDirectory, bool expectedIgnored)
     {
-        var ignore = new Ignore.Ignore();
-        ignore.Add("SPs");
-        Assert.True(ignore.IsIgnored("f:/cd/sps/ffffff.mkv"));
-        Assert.True(ignore.IsIgnored("cd/sps/ffffff.mkv"));
-        Assert.True(ignore.IsIgnored("/cd/sps/ffffff.mkv"));
+        // With normalizePath=true, backslashes should be converted to forward slashes
+        Assert.Equal(expectedIgnored, DotIgnoreIgnoreRule.CheckIgnoreRules(path, rules, isDirectory, normalizePath: true));
     }
 
-    [Fact]
-    public void TestNegatePattern()
+    [Theory]
+    [InlineData(@"C:\cd\sps\ffffff.mkv")]
+    [InlineData(@"D:\media\sps\movie.mkv")]
+    public void CheckIgnoreRules_WithWindowsPaths_WithoutNormalization_DoesNotMatch(string path)
     {
-        var ignore = new Ignore.Ignore();
-        ignore.Add("SPs");
-        ignore.Add("!thebestshot.mkv");
-        Assert.True(ignore.IsIgnored("f:/cd/sps/ffffff.mkv"));
-        Assert.True(ignore.IsIgnored("cd/sps/ffffff.mkv"));
-        Assert.True(ignore.IsIgnored("/cd/sps/ffffff.mkv"));
-        Assert.True(!ignore.IsIgnored("f:/cd/sps/thebestshot.mkv"));
-        Assert.True(!ignore.IsIgnored("cd/sps/thebestshot.mkv"));
-        Assert.True(!ignore.IsIgnored("/cd/sps/thebestshot.mkv"));
+        // Without normalization, Windows paths with backslashes won't match patterns expecting forward slashes
+        Assert.False(DotIgnoreIgnoreRule.CheckIgnoreRules(path, _rule1, isDirectory: false, normalizePath: false));
     }
 }
-- 
cgit v1.2.3


From 3c802a75054f316e04a5d914036f3164e8bf7e87 Mon Sep 17 00:00:00 2001
From: Shadowghost <Shadowghost@users.noreply.github.com>
Date: Sun, 28 Dec 2025 07:22:30 -0500
Subject: Backport pull request #15793 from jellyfin/release-10.11.z

Prefer US rating on fallback

Original-merge: 156761405e7fd5308474a7e6301839ae7c694dfa

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Bond_009 <bond.009@outlook.com>
---
 .../Localization/LocalizationManager.cs               | 10 +++++++---
 .../Localization/LocalizationManagerTests.cs          | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/Emby.Server.Implementations/Localization/LocalizationManager.cs b/Emby.Server.Implementations/Localization/LocalizationManager.cs
index b4c65ad85..d99ad4665 100644
--- a/Emby.Server.Implementations/Localization/LocalizationManager.cs
+++ b/Emby.Server.Implementations/Localization/LocalizationManager.cs
@@ -311,15 +311,19 @@ namespace Emby.Server.Implementations.Localization
             else
             {
                 // Fall back to server default language for ratings check
-                // If it has no ratings, use the US ratings
-                var ratingsDictionary = GetParentalRatingsDictionary() ?? GetParentalRatingsDictionary("us");
+                var ratingsDictionary = GetParentalRatingsDictionary();
                 if (ratingsDictionary is not null && ratingsDictionary.TryGetValue(rating, out ParentalRatingScore? value))
                 {
                     return value;
                 }
             }
 
-            // If we don't find anything, check all ratings systems
+            // If we don't find anything, check all ratings systems, starting with US
+            if (_allParentalRatings.TryGetValue("us", out var usRatings) && usRatings.TryGetValue(rating, out var usValue))
+            {
+                return usValue;
+            }
+
             foreach (var dictionary in _allParentalRatings.Values)
             {
                 if (dictionary.TryGetValue(rating, out var value))
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
index 6d6bba4fc..e60522bf7 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Localization/LocalizationManagerTests.cs
@@ -203,6 +203,25 @@ namespace Jellyfin.Server.Implementations.Tests.Localization
             Assert.Null(localizationManager.GetRatingScore(value));
         }
 
+        [Theory]
+        [InlineData("TV-MA", "DE", 17, 1)] // US-only rating, DE country code
+        [InlineData("PG-13", "FR", 13, 0)] // US-only rating, FR country code
+        [InlineData("R", "JP", 17, 0)] // US-only rating, JP country code
+        public async Task GetRatingScore_FallbackPrioritizesUS_Success(string rating, string countryCode, int expectedScore, int? expectedSubScore)
+        {
+            var localizationManager = Setup(new ServerConfiguration()
+            {
+                MetadataCountryCode = countryCode
+            });
+            await localizationManager.LoadAll();
+
+            var score = localizationManager.GetRatingScore(rating);
+
+            Assert.NotNull(score);
+            Assert.Equal(expectedScore, score.Score);
+            Assert.Equal(expectedSubScore, score.SubScore);
+        }
+
         [Theory]
         [InlineData("Default", "Default")]
         [InlineData("HeaderLiveTV", "Live TV")]
-- 
cgit v1.2.3


From 88acd51ee2b6a30a8a92a9e863fd4aaef48ee590 Mon Sep 17 00:00:00 2001
From: gnattu <gnattu@users.noreply.github.com>
Date: Sun, 28 Dec 2025 07:22:31 -0500
Subject: Backport pull request #15807 from jellyfin/release-10.11.z

Enforce more strict webm check

Original-merge: 8379b4634aeaf9827d07a41cf9ba8fd80c8c323e

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Bond_009 <bond.009@outlook.com>
---
 .../Probing/ProbeResultNormalizer.cs               |   9 +-
 .../Probing/ProbeResultNormalizerTests.cs          |  12 ++
 .../Probing/video_web_like_mkv_with_subtitle.json  | 137 +++++++++++++++++++++
 3 files changed, 155 insertions(+), 3 deletions(-)
 create mode 100644 tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_web_like_mkv_with_subtitle.json

(limited to 'tests')

diff --git a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
index 1823496bf..570ef9ee2 100644
--- a/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
+++ b/MediaBrowser.MediaEncoding/Probing/ProbeResultNormalizer.cs
@@ -300,9 +300,12 @@ namespace MediaBrowser.MediaEncoding.Probing
                 // Handle WebM
                 else if (string.Equals(splitFormat[i], "webm", StringComparison.OrdinalIgnoreCase))
                 {
-                    // Limit WebM to supported codecs
-                    if (mediaStreams.Any(stream => (stream.Type == MediaStreamType.Video && !_webmVideoCodecs.Contains(stream.Codec, StringComparison.OrdinalIgnoreCase))
-                        || (stream.Type == MediaStreamType.Audio && !_webmAudioCodecs.Contains(stream.Codec, StringComparison.OrdinalIgnoreCase))))
+                    // Limit WebM to supported stream types and codecs.
+                    // FFprobe can report "matroska,webm" for Matroska-like containers, so only keep "webm" if all streams are WebM-compatible.
+                    // Any stream that is not video nor audio is not supported in WebM and should disqualify the webm container probe result.
+                    if (mediaStreams.Any(stream => stream.Type is not MediaStreamType.Video and not MediaStreamType.Audio)
+                        || mediaStreams.Any(stream => (stream.Type == MediaStreamType.Video && !_webmVideoCodecs.Contains(stream.Codec, StringComparison.OrdinalIgnoreCase))
+                            || (stream.Type == MediaStreamType.Audio && !_webmAudioCodecs.Contains(stream.Codec, StringComparison.OrdinalIgnoreCase))))
                     {
                         splitFormat[i] = string.Empty;
                     }
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Probing/ProbeResultNormalizerTests.cs b/tests/Jellyfin.MediaEncoding.Tests/Probing/ProbeResultNormalizerTests.cs
index 94710a095..8a2f84734 100644
--- a/tests/Jellyfin.MediaEncoding.Tests/Probing/ProbeResultNormalizerTests.cs
+++ b/tests/Jellyfin.MediaEncoding.Tests/Probing/ProbeResultNormalizerTests.cs
@@ -195,6 +195,18 @@ namespace Jellyfin.MediaEncoding.Tests.Probing
             Assert.False(res.MediaStreams[0].IsAVC);
         }
 
+        [Fact]
+        public void GetMediaInfo_WebM_Like_Mkv()
+        {
+            var bytes = File.ReadAllBytes("Test Data/Probing/video_web_like_mkv_with_subtitle.json");
+            var internalMediaInfoResult = JsonSerializer.Deserialize<InternalMediaInfoResult>(bytes, _jsonOptions);
+
+            MediaInfo res = _probeResultNormalizer.GetMediaInfo(internalMediaInfoResult, VideoType.VideoFile, false, "Test Data/Probing/video_metadata.mkv", MediaProtocol.File);
+
+            Assert.Equal("mkv", res.Container);
+            Assert.Equal(3, res.MediaStreams.Count);
+        }
+
         [Fact]
         public void GetMediaInfo_ProgressiveVideoNoFieldOrder_Success()
         {
diff --git a/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_web_like_mkv_with_subtitle.json b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_web_like_mkv_with_subtitle.json
new file mode 100644
index 000000000..4f52dd90d
--- /dev/null
+++ b/tests/Jellyfin.MediaEncoding.Tests/Test Data/Probing/video_web_like_mkv_with_subtitle.json	
@@ -0,0 +1,137 @@
+{
+    "streams": [
+        {
+            "index": 0,
+            "codec_name": "vp8",
+            "codec_long_name": "On2 VP8",
+            "profile": "1",
+            "codec_type": "video",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "width": 540,
+            "height": 360,
+            "coded_width": 540,
+            "coded_height": 360,
+            "closed_captions": 0,
+            "film_grain": 0,
+            "has_b_frames": 0,
+            "sample_aspect_ratio": "1:1",
+            "display_aspect_ratio": "3:2",
+            "pix_fmt": "yuv420p",
+            "level": -99,
+            "field_order": "progressive",
+            "refs": 1,
+            "r_frame_rate": "2997/125",
+            "avg_frame_rate": "2997/125",
+            "time_base": "1/1000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0,
+                "captions": 0,
+                "descriptions": 0,
+                "metadata": 0,
+                "dependent": 0,
+                "still_image": 0
+            },
+            "tags": {
+                "language": "eng"
+            }
+        },
+        {
+            "index": 1,
+            "codec_name": "vorbis",
+            "codec_long_name": "Vorbis",
+            "codec_type": "audio",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "sample_fmt": "fltp",
+            "sample_rate": "44100",
+            "channels": 2,
+            "channel_layout": "stereo",
+            "bits_per_sample": 0,
+            "r_frame_rate": "0/0",
+            "avg_frame_rate": "0/0",
+            "time_base": "1/1000",
+            "start_pts": 0,
+            "start_time": "0.000000",
+            "duration": "117.707000",
+            "bit_rate": "127998",
+            "disposition": {
+                "default": 1,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0,
+                "captions": 0,
+                "descriptions": 0,
+                "metadata": 0,
+                "dependent": 0,
+                "still_image": 0
+            },
+            "tags": {
+                "language": "eng"
+            }
+        },
+        {
+            "index": 2,
+            "codec_name": "subrip",
+            "codec_long_name": "SubRip subtitle",
+            "codec_type": "subtitle",
+            "codec_tag_string": "[0][0][0][0]",
+            "codec_tag": "0x0000",
+            "disposition": {
+                "default": 0,
+                "dub": 0,
+                "original": 0,
+                "comment": 0,
+                "lyrics": 0,
+                "karaoke": 0,
+                "forced": 0,
+                "hearing_impaired": 0,
+                "visual_impaired": 0,
+                "clean_effects": 0,
+                "attached_pic": 0,
+                "timed_thumbnails": 0,
+                "captions": 0,
+                "descriptions": 0,
+                "metadata": 0,
+                "dependent": 0,
+                "still_image": 0
+            },
+            "tags": {
+                "language": "eng"
+            }
+        }
+    ],
+    "format": {
+        "filename": "sample.mkv",
+        "nb_streams": 3,
+        "nb_programs": 0,
+        "format_name": "matroska,webm",
+        "format_long_name": "Matroska / WebM",
+        "start_time": "0.000000",
+        "duration": "117.700914",
+        "size": "8566268",
+        "bit_rate": "582239",
+        "probe_score": 100
+    }
+}
-- 
cgit v1.2.3


From 90390772869495228793e1b29db20c8741a309de Mon Sep 17 00:00:00 2001
From: ZeusCraft10 <akhilachanta8@gmail.com>
Date: Mon, 5 Jan 2026 06:22:44 -0500
Subject: Fix zh-CN subtitle language display

The DisplayTitle property was using .NET's CultureInfo.GetCultures(NeutralCultures)
to resolve language display names. Since zh-CN is a specific culture (not neutral),
it would fall back to the base 'zh' code, resulting in generic 'Chinese' instead
of 'Chinese (Simplified)'.

This change adds a LocalizedLanguage property to MediaStream that gets populated
via LocalizationManager.FindLanguageInfo() when streams are retrieved from the
database. This leverages Jellyfin's existing iso6392.txt mappings which correctly
map zh-CN to 'Chinese (Simplified)'.

The same pattern is already used for other localized strings like LocalizedDefault
and LocalizedExternal.
---
 .../Item/MediaStreamRepository.cs                  |  6 +++
 MediaBrowser.Model/Entities/MediaStream.cs         | 52 +++-------------------
 .../Entities/MediaStreamTests.cs                   | 43 ++++++++++++++++++
 3 files changed, 55 insertions(+), 46 deletions(-)

(limited to 'tests')

diff --git a/Jellyfin.Server.Implementations/Item/MediaStreamRepository.cs b/Jellyfin.Server.Implementations/Item/MediaStreamRepository.cs
index 7eb13b740..64874ccad 100644
--- a/Jellyfin.Server.Implementations/Item/MediaStreamRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/MediaStreamRepository.cs
@@ -158,6 +158,12 @@ public class MediaStreamRepository : IMediaStreamRepository
             dto.LocalizedDefault = _localization.GetLocalizedString("Default");
             dto.LocalizedExternal = _localization.GetLocalizedString("External");
 
+            if (!string.IsNullOrEmpty(dto.Language))
+            {
+                var culture = _localization.FindLanguageInfo(dto.Language);
+                dto.LocalizedLanguage = culture?.DisplayName;
+            }
+
             if (dto.Type is MediaStreamType.Subtitle)
             {
                 dto.LocalizedUndefined = _localization.GetLocalizedString("Undefined");
diff --git a/MediaBrowser.Model/Entities/MediaStream.cs b/MediaBrowser.Model/Entities/MediaStream.cs
index b1626e2c9..c443af32c 100644
--- a/MediaBrowser.Model/Entities/MediaStream.cs
+++ b/MediaBrowser.Model/Entities/MediaStream.cs
@@ -260,6 +260,8 @@ namespace MediaBrowser.Model.Entities
 
         public string LocalizedHearingImpaired { get; set; }
 
+        public string LocalizedLanguage { get; set; }
+
         public string DisplayTitle
         {
             get
@@ -273,29 +275,8 @@ namespace MediaBrowser.Model.Entities
                         // Do not display the language code in display titles if unset or set to a special code. Show it in all other cases (possibly expanded).
                         if (!string.IsNullOrEmpty(Language) && !_specialCodes.Contains(Language, StringComparison.OrdinalIgnoreCase))
                         {
-                            // Get full language string i.e. eng -> English, zh-Hans -> Chinese (Simplified).
-                            var cultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
-                            CultureInfo match = null;
-                            if (Language.Contains('-', StringComparison.OrdinalIgnoreCase))
-                            {
-                                match = cultures.FirstOrDefault(r =>
-                                    r.Name.Equals(Language, StringComparison.OrdinalIgnoreCase));
-
-                                if (match is null)
-                                {
-                                    string baseLang = Language.AsSpan().LeftPart('-').ToString();
-                                    match = cultures.FirstOrDefault(r =>
-                                        r.TwoLetterISOLanguageName.Equals(baseLang, StringComparison.OrdinalIgnoreCase));
-                                }
-                            }
-                            else
-                            {
-                                match = cultures.FirstOrDefault(r =>
-                                    r.ThreeLetterISOLanguageName.Equals(Language, StringComparison.OrdinalIgnoreCase));
-                            }
-
-                            string fullLanguage = match?.DisplayName;
-                            attributes.Add(StringHelper.FirstToUpper(fullLanguage ?? Language));
+                            // Use pre-resolved localized language name, falling back to raw language code.
+                            attributes.Add(StringHelper.FirstToUpper(LocalizedLanguage ?? Language));
                         }
 
                         if (!string.IsNullOrEmpty(Profile) && !string.Equals(Profile, "lc", StringComparison.OrdinalIgnoreCase))
@@ -393,29 +374,8 @@ namespace MediaBrowser.Model.Entities
 
                         if (!string.IsNullOrEmpty(Language))
                         {
-                            // Get full language string i.e. eng -> English, zh-Hans -> Chinese (Simplified).
-                            var cultures = CultureInfo.GetCultures(CultureTypes.NeutralCultures);
-                            CultureInfo match = null;
-                            if (Language.Contains('-', StringComparison.OrdinalIgnoreCase))
-                            {
-                                match = cultures.FirstOrDefault(r =>
-                                    r.Name.Equals(Language, StringComparison.OrdinalIgnoreCase));
-
-                                if (match is null)
-                                {
-                                    string baseLang = Language.AsSpan().LeftPart('-').ToString();
-                                    match = cultures.FirstOrDefault(r =>
-                                        r.TwoLetterISOLanguageName.Equals(baseLang, StringComparison.OrdinalIgnoreCase));
-                                }
-                            }
-                            else
-                            {
-                                match = cultures.FirstOrDefault(r =>
-                                    r.ThreeLetterISOLanguageName.Equals(Language, StringComparison.OrdinalIgnoreCase));
-                            }
-
-                            string fullLanguage = match?.DisplayName;
-                            attributes.Add(StringHelper.FirstToUpper(fullLanguage ?? Language));
+                            // Use pre-resolved localized language name, falling back to raw language code.
+                            attributes.Add(StringHelper.FirstToUpper(LocalizedLanguage ?? Language));
                         }
                         else
                         {
diff --git a/tests/Jellyfin.Model.Tests/Entities/MediaStreamTests.cs b/tests/Jellyfin.Model.Tests/Entities/MediaStreamTests.cs
index f4c0d9fe8..c1a3a4544 100644
--- a/tests/Jellyfin.Model.Tests/Entities/MediaStreamTests.cs
+++ b/tests/Jellyfin.Model.Tests/Entities/MediaStreamTests.cs
@@ -108,6 +108,49 @@ namespace Jellyfin.Model.Tests.Entities
                     IsExternal = true
                 });
 
+            // Test LocalizedLanguage is used when set (fixes zh-CN display issue #15935)
+            data.Add(
+                "Chinese (Simplified) - SRT",
+                new MediaStream
+                {
+                    Type = MediaStreamType.Subtitle,
+                    Title = null,
+                    Language = "zh-CN",
+                    LocalizedLanguage = "Chinese (Simplified)",
+                    IsForced = false,
+                    IsDefault = false,
+                    Codec = "SRT"
+                });
+
+            // Test LocalizedLanguage for audio streams
+            data.Add(
+                "Japanese - AAC - Stereo",
+                new MediaStream
+                {
+                    Type = MediaStreamType.Audio,
+                    Title = null,
+                    Language = "jpn",
+                    LocalizedLanguage = "Japanese",
+                    IsForced = false,
+                    IsDefault = false,
+                    Codec = "AAC",
+                    ChannelLayout = "stereo"
+                });
+
+            // Test fallback to Language when LocalizedLanguage is null
+            data.Add(
+                "Eng - ASS",
+                new MediaStream
+                {
+                    Type = MediaStreamType.Subtitle,
+                    Title = null,
+                    Language = "eng",
+                    LocalizedLanguage = null,
+                    IsForced = false,
+                    IsDefault = false,
+                    Codec = "ASS"
+                });
+
             return data;
         }
 
-- 
cgit v1.2.3


From 0ff869dfcd4ab527dccc975c9be414d1c050a90d Mon Sep 17 00:00:00 2001
From: ZeusCraft10 <akhilachanta8@gmail.com>
Date: Mon, 5 Jan 2026 21:08:26 -0500
Subject: fix: Handle unknown item types gracefully in DeserializeBaseItem

When querying items with recursive=true, items with types from removed
plugins would cause a 500 error. Now these items are skipped with a
warning log instead of throwing an exception.

Fixes #15945
---
 .../Item/BaseItemRepository.cs                     | 40 +++++++-----
 .../Migrations/Routines/MigrateLibraryDb.cs        |  7 ++-
 .../Item/BaseItemRepositoryTests.cs                | 72 ++++++++++++++++++++++
 3 files changed, 100 insertions(+), 19 deletions(-)
 create mode 100644 tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryTests.cs

(limited to 'tests')

diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 85ab00a2b..b7f1c23e0 100644
--- a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
+++ b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
@@ -277,7 +277,7 @@ public sealed class BaseItemRepository
         dbQuery = ApplyQueryPaging(dbQuery, filter);
         dbQuery = ApplyNavigations(dbQuery, filter);
 
-        result.Items = dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).ToArray();
+        result.Items = dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).Where(dto => dto is not null).ToArray()!;
         result.StartIndex = filter.StartIndex ?? 0;
         return result;
     }
@@ -297,7 +297,7 @@ public sealed class BaseItemRepository
         dbQuery = ApplyQueryPaging(dbQuery, filter);
         dbQuery = ApplyNavigations(dbQuery, filter);
 
-        return dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).ToArray();
+        return dbQuery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).Where(dto => dto is not null).ToArray()!;
     }
 
     /// <inheritdoc/>
@@ -341,7 +341,7 @@ public sealed class BaseItemRepository
 
         mainquery = ApplyNavigations(mainquery, filter);
 
-        return mainquery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).ToArray();
+        return mainquery.AsEnumerable().Where(e => e is not null).Select(w => DeserializeBaseItem(w, filter.SkipDeserialization)).Where(dto => dto is not null).ToArray()!;
     }
 
     /// <inheritdoc />
@@ -1159,7 +1159,7 @@ public sealed class BaseItemRepository
         return type.GetCustomAttribute<RequiresSourceSerialisationAttribute>() == null;
     }
 
-    private BaseItemDto DeserializeBaseItem(BaseItemEntity baseItemEntity, bool skipDeserialization = false)
+    private BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, bool skipDeserialization = false)
     {
         ArgumentNullException.ThrowIfNull(baseItemEntity, nameof(baseItemEntity));
         if (_serverConfigurationManager?.Configuration is null)
@@ -1182,11 +1182,19 @@ public sealed class BaseItemRepository
     /// <param name="logger">Logger.</param>
     /// <param name="appHost">The application server Host.</param>
     /// <param name="skipDeserialization">If only mapping should be processed.</param>
-    /// <returns>A mapped BaseItem.</returns>
-    /// <exception cref="InvalidOperationException">Will be thrown if an invalid serialisation is requested.</exception>
-    public static BaseItemDto DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost? appHost, bool skipDeserialization = false)
+    /// <returns>A mapped BaseItem, or null if the item type is unknown.</returns>
+    public static BaseItemDto? DeserializeBaseItem(BaseItemEntity baseItemEntity, ILogger logger, IServerApplicationHost? appHost, bool skipDeserialization = false)
     {
-        var type = GetType(baseItemEntity.Type) ?? throw new InvalidOperationException("Cannot deserialize unknown type.");
+        var type = GetType(baseItemEntity.Type);
+        if (type is null)
+        {
+            logger.LogWarning(
+                "Skipping item {ItemId} with unknown type '{ItemType}'. This may indicate a removed plugin or database corruption.",
+                baseItemEntity.Id,
+                baseItemEntity.Type);
+            return null;
+        }
+
         BaseItemDto? dto = null;
         if (TypeRequiresDeserialization(type) && baseItemEntity.Data is not null && !skipDeserialization)
         {
@@ -1353,10 +1361,9 @@ public sealed class BaseItemRepository
                 .. resultQuery
                     .AsEnumerable()
                     .Where(e => e is not null)
-                    .Select(e =>
-                    {
-                        return (DeserializeBaseItem(e.item, filter.SkipDeserialization), e.itemCount);
-                    })
+                    .Select(e => (Item: DeserializeBaseItem(e.item, filter.SkipDeserialization), e.itemCount))
+                    .Where(e => e.Item is not null)
+                    .Select(e => (e.Item!, e.itemCount))
             ];
         }
         else
@@ -1367,10 +1374,9 @@ public sealed class BaseItemRepository
                 .. query
                     .AsEnumerable()
                     .Where(e => e is not null)
-                    .Select<BaseItemEntity, (BaseItemDto, ItemCounts?)>(e =>
-                    {
-                        return (DeserializeBaseItem(e, filter.SkipDeserialization), null);
-                    })
+                    .Select(e => (Item: DeserializeBaseItem(e, filter.SkipDeserialization), ItemCounts: (ItemCounts?)null))
+                    .Where(e => e.Item is not null)
+                    .Select(e => (e.Item!, e.ItemCounts))
             ];
         }
 
@@ -2671,6 +2677,6 @@ public sealed class BaseItemRepository
             .Where(e => artistNames.Contains(e.Name))
             .ToArray();
 
-        return artists.GroupBy(e => e.Name).ToDictionary(e => e.Key!, e => e.Select(f => DeserializeBaseItem(f)).Cast<MusicArtist>().ToArray());
+        return artists.GroupBy(e => e.Name).ToDictionary(e => e.Key!, e => e.Select(f => DeserializeBaseItem(f)).Where(dto => dto is not null).Cast<MusicArtist>().ToArray());
     }
 }
diff --git a/Jellyfin.Server/Migrations/Routines/MigrateLibraryDb.cs b/Jellyfin.Server/Migrations/Routines/MigrateLibraryDb.cs
index d221d1853..4b1e53a35 100644
--- a/Jellyfin.Server/Migrations/Routines/MigrateLibraryDb.cs
+++ b/Jellyfin.Server/Migrations/Routines/MigrateLibraryDb.cs
@@ -1247,8 +1247,11 @@ internal class MigrateLibraryDb : IDatabaseMigrationRoutine
         }
 
         var baseItem = BaseItemRepository.DeserializeBaseItem(entity, _logger, null, false);
-        var dataKeys = baseItem.GetUserDataKeys();
-        userDataKeys.AddRange(dataKeys);
+        if (baseItem is not null)
+        {
+            var dataKeys = baseItem.GetUserDataKeys();
+            userDataKeys.AddRange(dataKeys);
+        }
 
         return (entity, userDataKeys.ToArray());
     }
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryTests.cs
new file mode 100644
index 000000000..c450cbb0e
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Item/BaseItemRepositoryTests.cs
@@ -0,0 +1,72 @@
+using System;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Server.Implementations.Item;
+using MediaBrowser.Controller;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Item;
+
+public class BaseItemRepositoryTests
+{
+    [Fact]
+    public void DeserializeBaseItem_WithUnknownType_ReturnsNull()
+    {
+        // Arrange
+        var entity = new BaseItemEntity
+        {
+            Id = Guid.NewGuid(),
+            Type = "NonExistent.Plugin.CustomItemType"
+        };
+
+        // Act
+        var result = BaseItemRepository.DeserializeBaseItem(entity, NullLogger.Instance, null, false);
+
+        // Assert
+        Assert.Null(result);
+    }
+
+    [Fact]
+    public void DeserializeBaseItem_WithUnknownType_LogsWarning()
+    {
+        // Arrange
+        var entity = new BaseItemEntity
+        {
+            Id = Guid.NewGuid(),
+            Type = "NonExistent.Plugin.CustomItemType"
+        };
+        var loggerMock = new Mock<ILogger>();
+
+        // Act
+        BaseItemRepository.DeserializeBaseItem(entity, loggerMock.Object, null, false);
+
+        // Assert
+        loggerMock.Verify(
+            x => x.Log(
+                LogLevel.Warning,
+                It.IsAny<EventId>(),
+                It.Is<It.IsAnyType>((v, t) => v.ToString()!.Contains("unknown type", StringComparison.OrdinalIgnoreCase)),
+                It.IsAny<Exception?>(),
+                It.IsAny<Func<It.IsAnyType, Exception?, string>>()),
+            Times.Once);
+    }
+
+    [Fact]
+    public void DeserializeBaseItem_WithKnownType_ReturnsItem()
+    {
+        // Arrange
+        var entity = new BaseItemEntity
+        {
+            Id = Guid.NewGuid(),
+            Type = "MediaBrowser.Controller.Entities.Movies.Movie"
+        };
+
+        // Act
+        var result = BaseItemRepository.DeserializeBaseItem(entity, NullLogger.Instance, null, false);
+
+        // Assert
+        Assert.NotNull(result);
+    }
+}
-- 
cgit v1.2.3


From 244757c92cae8dc1cb12dfb4a4e976bbfd7e751d Mon Sep 17 00:00:00 2001
From: ZeusCraft10 <akhilachanta8@gmail.com>
Date: Mon, 5 Jan 2026 23:03:22 -0500
Subject: Fix KeyNotFoundException in CryptographyProvider.Verify

When a password hash is missing the 'iterations' parameter, Verify now
throws a descriptive FormatException instead of KeyNotFoundException.

- Extract GetIterationsParameter() helper method to avoid code duplication
- Provide distinct error messages for missing vs invalid parameters
- Add comprehensive unit tests for CryptographyProvider
---
 CONTRIBUTORS.md                                    |   1 +
 .../Cryptography/CryptographyProvider.cs           |  27 +++++-
 .../Cryptography/CryptographyProviderTests.cs      | 102 +++++++++++++++++++++
 3 files changed, 128 insertions(+), 2 deletions(-)
 create mode 100644 tests/Jellyfin.Server.Implementations.Tests/Cryptography/CryptographyProviderTests.cs

(limited to 'tests')

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 0fd509f84..171509382 100644
--- a/CONTRIBUTORS.md
+++ b/CONTRIBUTORS.md
@@ -209,6 +209,7 @@
  - [Kirill Nikiforov](https://github.com/allmazz)
  - [bjorntp](https://github.com/bjorntp)
  - [martenumberto](https://github.com/martenumberto)
+ - [ZeusCraft10](https://github.com/ZeusCraft10)
 
 # Emby Contributors
 
diff --git a/Emby.Server.Implementations/Cryptography/CryptographyProvider.cs b/Emby.Server.Implementations/Cryptography/CryptographyProvider.cs
index 5380c45d8..0381c4d35 100644
--- a/Emby.Server.Implementations/Cryptography/CryptographyProvider.cs
+++ b/Emby.Server.Implementations/Cryptography/CryptographyProvider.cs
@@ -39,22 +39,24 @@ namespace Emby.Server.Implementations.Cryptography
         {
             if (string.Equals(hash.Id, "PBKDF2", StringComparison.Ordinal))
             {
+                var iterations = GetIterationsParameter(hash);
                 return hash.Hash.SequenceEqual(
                     Rfc2898DeriveBytes.Pbkdf2(
                         password,
                         hash.Salt,
-                        int.Parse(hash.Parameters["iterations"], CultureInfo.InvariantCulture),
+                        iterations,
                         HashAlgorithmName.SHA1,
                         32));
             }
 
             if (string.Equals(hash.Id, "PBKDF2-SHA512", StringComparison.Ordinal))
             {
+                var iterations = GetIterationsParameter(hash);
                 return hash.Hash.SequenceEqual(
                     Rfc2898DeriveBytes.Pbkdf2(
                         password,
                         hash.Salt,
-                        int.Parse(hash.Parameters["iterations"], CultureInfo.InvariantCulture),
+                        iterations,
                         HashAlgorithmName.SHA512,
                         DefaultOutputLength));
             }
@@ -62,6 +64,27 @@ namespace Emby.Server.Implementations.Cryptography
             throw new NotSupportedException($"Can't verify hash with id: {hash.Id}");
         }
 
+        /// <summary>
+        /// Extracts and validates the iterations parameter from a password hash.
+        /// </summary>
+        /// <param name="hash">The password hash containing parameters.</param>
+        /// <returns>The number of iterations.</returns>
+        /// <exception cref="FormatException">Thrown when iterations parameter is missing or invalid.</exception>
+        private static int GetIterationsParameter(PasswordHash hash)
+        {
+            if (!hash.Parameters.TryGetValue("iterations", out var iterationsStr))
+            {
+                throw new FormatException($"Password hash with id '{hash.Id}' is missing required 'iterations' parameter.");
+            }
+
+            if (!int.TryParse(iterationsStr, CultureInfo.InvariantCulture, out var iterations))
+            {
+                throw new FormatException($"Password hash with id '{hash.Id}' has invalid 'iterations' parameter: '{iterationsStr}'.");
+            }
+
+            return iterations;
+        }
+
         /// <inheritdoc />
         public byte[] GenerateSalt()
             => GenerateSalt(DefaultSaltLength);
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Cryptography/CryptographyProviderTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Cryptography/CryptographyProviderTests.cs
new file mode 100644
index 000000000..052bdf740
--- /dev/null
+++ b/tests/Jellyfin.Server.Implementations.Tests/Cryptography/CryptographyProviderTests.cs
@@ -0,0 +1,102 @@
+using System;
+using Emby.Server.Implementations.Cryptography;
+using MediaBrowser.Model.Cryptography;
+using Xunit;
+
+namespace Jellyfin.Server.Implementations.Tests.Cryptography;
+
+public class CryptographyProviderTests
+{
+    private readonly CryptographyProvider _sut = new();
+
+    [Fact]
+    public void CreatePasswordHash_WithPassword_ReturnsHashWithIterations()
+    {
+        var hash = _sut.CreatePasswordHash("testpassword");
+
+        Assert.Equal("PBKDF2-SHA512", hash.Id);
+        Assert.True(hash.Parameters.ContainsKey("iterations"));
+        Assert.NotEmpty(hash.Salt.ToArray());
+        Assert.NotEmpty(hash.Hash.ToArray());
+    }
+
+    [Fact]
+    public void Verify_WithValidPassword_ReturnsTrue()
+    {
+        const string password = "testpassword";
+        var hash = _sut.CreatePasswordHash(password);
+
+        Assert.True(_sut.Verify(hash, password));
+    }
+
+    [Fact]
+    public void Verify_WithWrongPassword_ReturnsFalse()
+    {
+        var hash = _sut.CreatePasswordHash("correctpassword");
+
+        Assert.False(_sut.Verify(hash, "wrongpassword"));
+    }
+
+    [Fact]
+    public void Verify_PBKDF2_MissingIterations_ThrowsFormatException()
+    {
+        var hash = PasswordHash.Parse("$PBKDF2$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        var exception = Assert.Throws<FormatException>(() => _sut.Verify(hash, "password"));
+        Assert.Contains("missing required 'iterations' parameter", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Verify_PBKDF2SHA512_MissingIterations_ThrowsFormatException()
+    {
+        var hash = PasswordHash.Parse("$PBKDF2-SHA512$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        var exception = Assert.Throws<FormatException>(() => _sut.Verify(hash, "password"));
+        Assert.Contains("missing required 'iterations' parameter", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Verify_PBKDF2_InvalidIterationsFormat_ThrowsFormatException()
+    {
+        var hash = PasswordHash.Parse("$PBKDF2$iterations=abc$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        var exception = Assert.Throws<FormatException>(() => _sut.Verify(hash, "password"));
+        Assert.Contains("invalid 'iterations' parameter", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Verify_PBKDF2SHA512_InvalidIterationsFormat_ThrowsFormatException()
+    {
+        var hash = PasswordHash.Parse("$PBKDF2-SHA512$iterations=notanumber$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        var exception = Assert.Throws<FormatException>(() => _sut.Verify(hash, "password"));
+        Assert.Contains("invalid 'iterations' parameter", exception.Message, StringComparison.Ordinal);
+    }
+
+    [Fact]
+    public void Verify_UnsupportedHashId_ThrowsNotSupportedException()
+    {
+        var hash = PasswordHash.Parse("$UNKNOWN$69F420$62FBA410AFCA5B4475F35137AB2E8596B127E4D927BA23F6CC05C067E897042D");
+
+        Assert.Throws<NotSupportedException>(() => _sut.Verify(hash, "password"));
+    }
+
+    [Fact]
+    public void GenerateSalt_ReturnsNonEmptyArray()
+    {
+        var salt = _sut.GenerateSalt();
+
+        Assert.NotEmpty(salt);
+    }
+
+    [Theory]
+    [InlineData(16)]
+    [InlineData(32)]
+    [InlineData(64)]
+    public void GenerateSalt_WithLength_ReturnsArrayOfSpecifiedLength(int length)
+    {
+        var salt = _sut.GenerateSalt(length);
+
+        Assert.Equal(length, salt.Length);
+    }
+}
-- 
cgit v1.2.3


From 9e480f6efb4bc0e1f0d1323ed7ed5a7208fded99 Mon Sep 17 00:00:00 2001
From: Bond_009 <bond.009@outlook.com>
Date: Tue, 11 Nov 2025 17:41:46 +0100
Subject: Update to .NET 10.0

---
 .editorconfig                                      |  7 ++++
 .github/workflows/ci-openapi.yml                   |  4 +-
 .vscode/launch.json                                |  6 +--
 Directory.Packages.props                           | 47 +++++++++-------------
 Emby.Naming/Emby.Naming.csproj                     |  2 +-
 Emby.Photos/Emby.Photos.csproj                     |  2 +-
 .../Emby.Server.Implementations.csproj             |  3 +-
 Jellyfin.Api/Helpers/HlsHelpers.cs                 | 10 +----
 Jellyfin.Api/Jellyfin.Api.csproj                   |  2 +-
 Jellyfin.Data/Jellyfin.Data.csproj                 |  2 +-
 .../FullSystemBackup/BackupService.cs              | 15 +++----
 .../Jellyfin.Server.Implementations.csproj         |  3 +-
 .../Extensions/ApiServiceCollectionExtensions.cs   | 11 ++---
 Jellyfin.Server/Jellyfin.Server.csproj             |  5 +--
 MediaBrowser.Common/MediaBrowser.Common.csproj     |  7 +---
 MediaBrowser.Common/Net/NetworkConstants.cs        |  1 -
 MediaBrowser.Common/Net/NetworkUtils.cs            | 10 ++---
 .../MediaBrowser.Controller.csproj                 |  4 +-
 .../MediaBrowser.LocalMetadata.csproj              |  2 +-
 .../MediaBrowser.MediaEncoding.csproj              |  3 +-
 MediaBrowser.Model/MediaBrowser.Model.csproj       |  5 +--
 MediaBrowser.Model/Net/IPData.cs                   |  5 +--
 .../MediaBrowser.Providers.csproj                  |  3 +-
 .../MediaBrowser.XbmcMetadata.csproj               |  2 +-
 README.md                                          |  4 +-
 .../Emby.Server.Implementations.Fuzz.csproj        |  2 +-
 fuzz/Emby.Server.Implementations.Fuzz/fuzz.sh      |  2 +-
 fuzz/Jellyfin.Api.Fuzz/Jellyfin.Api.Fuzz.csproj    |  2 +-
 fuzz/Jellyfin.Api.Fuzz/fuzz.sh                     |  2 +-
 global.json                                        |  2 +-
 .../Jellyfin.Database.Implementations.csproj       |  2 +-
 .../Locking/OptimisticLockBehavior.cs              |  2 +
 .../Locking/PessimisticLockBehavior.cs             |  1 +
 .../Jellyfin.Database.Providers.Sqlite.csproj      |  2 +-
 .../Jellyfin.Drawing.Skia.csproj                   |  2 +-
 src/Jellyfin.Drawing/Jellyfin.Drawing.csproj       |  2 +-
 src/Jellyfin.Extensions/Jellyfin.Extensions.csproj |  2 +-
 src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj         |  3 +-
 .../Jellyfin.MediaEncoding.Hls.csproj              |  5 +--
 .../Jellyfin.MediaEncoding.Keyframes.csproj        |  6 +--
 src/Jellyfin.Networking/Jellyfin.Networking.csproj |  2 +-
 src/Jellyfin.Networking/Manager/NetworkManager.cs  | 21 +++++-----
 tests/Directory.Build.props                        |  2 +-
 tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj |  1 -
 .../Jellyfin.LiveTv.Tests.csproj                   |  2 +-
 .../Jellyfin.Server.Integration.Tests.csproj       |  1 -
 .../Jellyfin.Server.Tests.csproj                   |  1 -
 tests/Jellyfin.Server.Tests/ParseNetworkTests.cs   |  7 ++--
 48 files changed, 99 insertions(+), 140 deletions(-)

(limited to 'tests')

diff --git a/.editorconfig b/.editorconfig
index 313b02563..fa679f120 100644
--- a/.editorconfig
+++ b/.editorconfig
@@ -379,6 +379,9 @@ dotnet_diagnostic.CA1720.severity = suggestion
 # disable warning CA1724: Type names should not match namespaces
 dotnet_diagnostic.CA1724.severity = suggestion
 
+# disable warning CA1873: Avoid potentially expensive logging
+dotnet_diagnostic.CA1873.severity = suggestion
+
 # disable warning CA1805: Do not initialize unnecessarily
 dotnet_diagnostic.CA1805.severity = suggestion
 
@@ -400,6 +403,10 @@ dotnet_diagnostic.CA1861.severity = suggestion
 # disable warning CA2000: Dispose objects before losing scope
 dotnet_diagnostic.CA2000.severity = suggestion
 
+# TODO: Reevaluate when false positives are fixed: https://github.com/dotnet/roslyn-analyzers/issues/7699
+# disable warning CA2025: Do not pass 'IDisposable' instances into unawaited tasks
+dotnet_diagnostic.CA2025.severity = suggestion
+
 # disable warning CA2253: Named placeholders should not be numeric values
 dotnet_diagnostic.CA2253.severity = suggestion
 
diff --git a/.github/workflows/ci-openapi.yml b/.github/workflows/ci-openapi.yml
index 8406d1d2d..cf2a2868d 100644
--- a/.github/workflows/ci-openapi.yml
+++ b/.github/workflows/ci-openapi.yml
@@ -35,7 +35,7 @@ jobs:
           name: openapi-head
           retention-days: 14
           if-no-files-found: error
-          path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net9.0/openapi.json
+          path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net10.0/openapi.json
 
   openapi-base:
     name: OpenAPI - BASE
@@ -73,7 +73,7 @@ jobs:
           name: openapi-base
           retention-days: 14
           if-no-files-found: error
-          path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net9.0/openapi.json
+          path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net10.0/openapi.json
 
   openapi-diff:
     permissions:
diff --git a/.vscode/launch.json b/.vscode/launch.json
index d97d8de84..681f068b9 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -6,7 +6,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": [],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",
@@ -22,7 +22,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": ["--nowebclient"],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",
@@ -34,7 +34,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": ["--nowebclient", "--ffmpeg", "/usr/lib/jellyfin-ffmpeg/ffmpeg"],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",
diff --git a/Directory.Packages.props b/Directory.Packages.props
index 31b46da61..d78e2d021 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -26,32 +26,27 @@
     <PackageVersion Include="libse" Version="4.0.12" />
     <PackageVersion Include="LrcParser" Version="2025.623.0" />
     <PackageVersion Include="MetaBrainz.MusicBrainz" Version="7.0.0" />
-    <PackageVersion Include="Microsoft.AspNetCore.Authorization" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.AspNetCore.Authorization" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="4.14.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="4.14.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" />
-    <PackageVersion Include="Microsoft.Data.Sqlite" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Abstractions" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Http" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Logging" Version="9.0.11" />
-    <PackageVersion Include="Microsoft.Extensions.Options" Version="9.0.11" />
+    <PackageVersion Include="Microsoft.Data.Sqlite" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Tools" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Http" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Logging" Version="10.0.0" />
+    <PackageVersion Include="Microsoft.Extensions.Options" Version="10.0.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
     <PackageVersion Include="MimeTypes" Version="2.5.2" />
     <PackageVersion Include="Morestachio" Version="5.0.1.631" />
@@ -81,12 +76,8 @@
     <PackageVersion Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
     <PackageVersion Include="Svg.Skia" Version="3.2.1" />
     <PackageVersion Include="Swashbuckle.AspNetCore.ReDoc" Version="6.9.0" />
-    <PackageVersion Include="Swashbuckle.AspNetCore" Version="6.9.0" />
-    <PackageVersion Include="System.Globalization" Version="4.3.0" />
-    <PackageVersion Include="System.Linq.Async" Version="6.0.3" />
-    <PackageVersion Include="System.Text.Encoding.CodePages" Version="9.0.11" />
-    <PackageVersion Include="System.Text.Json" Version="9.0.11" />
-    <PackageVersion Include="System.Threading.Tasks.Dataflow" Version="9.0.11" />
+    <PackageVersion Include="Swashbuckle.AspNetCore" Version="7.3.2" />
+    <PackageVersion Include="System.Text.Json" Version="10.0.0" />
     <PackageVersion Include="TagLibSharp" Version="2.3.0" />
     <PackageVersion Include="z440.atl.core" Version="7.10.0" />
     <PackageVersion Include="TMDbLib" Version="2.3.0" />
diff --git a/Emby.Naming/Emby.Naming.csproj b/Emby.Naming/Emby.Naming.csproj
index b84c96116..97b52e42a 100644
--- a/Emby.Naming/Emby.Naming.csproj
+++ b/Emby.Naming/Emby.Naming.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
diff --git a/Emby.Photos/Emby.Photos.csproj b/Emby.Photos/Emby.Photos.csproj
index 645a74aea..3faeae380 100644
--- a/Emby.Photos/Emby.Photos.csproj
+++ b/Emby.Photos/Emby.Photos.csproj
@@ -19,7 +19,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/Emby.Server.Implementations/Emby.Server.Implementations.csproj b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
index 15843730e..f312fb4db 100644
--- a/Emby.Server.Implementations/Emby.Server.Implementations.csproj
+++ b/Emby.Server.Implementations/Emby.Server.Implementations.csproj
@@ -27,7 +27,6 @@
     <PackageReference Include="Microsoft.Data.Sqlite" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
     <PackageReference Include="prometheus-net.DotNetRuntime" />
@@ -39,7 +38,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/Jellyfin.Api/Helpers/HlsHelpers.cs b/Jellyfin.Api/Helpers/HlsHelpers.cs
index cad8d650e..15540338b 100644
--- a/Jellyfin.Api/Helpers/HlsHelpers.cs
+++ b/Jellyfin.Api/Helpers/HlsHelpers.cs
@@ -45,15 +45,9 @@ public static class HlsHelpers
                     using var reader = new StreamReader(fileStream);
                     var count = 0;
 
-                    while (!reader.EndOfStream)
+                    string? line;
+                    while ((line = await reader.ReadLineAsync(cancellationToken).ConfigureAwait(false)) is not null)
                     {
-                        var line = await reader.ReadLineAsync(cancellationToken).ConfigureAwait(false);
-                        if (line is null)
-                        {
-                            // Nothing currently in buffer.
-                            break;
-                        }
-
                         if (line.Contains("#EXTINF:", StringComparison.OrdinalIgnoreCase))
                         {
                             count++;
diff --git a/Jellyfin.Api/Jellyfin.Api.csproj b/Jellyfin.Api/Jellyfin.Api.csproj
index 25feaa2d7..3ccf7a746 100644
--- a/Jellyfin.Api/Jellyfin.Api.csproj
+++ b/Jellyfin.Api/Jellyfin.Api.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
 
diff --git a/Jellyfin.Data/Jellyfin.Data.csproj b/Jellyfin.Data/Jellyfin.Data.csproj
index fd852ece9..f7660f35d 100644
--- a/Jellyfin.Data/Jellyfin.Data.csproj
+++ b/Jellyfin.Data/Jellyfin.Data.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
diff --git a/Jellyfin.Server.Implementations/FullSystemBackup/BackupService.cs b/Jellyfin.Server.Implementations/FullSystemBackup/BackupService.cs
index 70483c36c..30094a88c 100644
--- a/Jellyfin.Server.Implementations/FullSystemBackup/BackupService.cs
+++ b/Jellyfin.Server.Implementations/FullSystemBackup/BackupService.cs
@@ -102,7 +102,7 @@ public class BackupService : IBackupService
             }
 
             BackupManifest? manifest;
-            var manifestStream = zipArchiveEntry.Open();
+            var manifestStream = await zipArchiveEntry.OpenAsync().ConfigureAwait(false);
             await using (manifestStream.ConfigureAwait(false))
             {
                 manifest = await JsonSerializer.DeserializeAsync<BackupManifest>(manifestStream, _serializerSettings).ConfigureAwait(false);
@@ -160,7 +160,7 @@ public class BackupService : IBackupService
                     }
 
                     HistoryRow[] historyEntries;
-                    var historyArchive = historyEntry.Open();
+                    var historyArchive = await historyEntry.OpenAsync().ConfigureAwait(false);
                     await using (historyArchive.ConfigureAwait(false))
                     {
                         historyEntries = await JsonSerializer.DeserializeAsync<HistoryRow[]>(historyArchive).ConfigureAwait(false) ??
@@ -204,7 +204,7 @@ public class BackupService : IBackupService
                             continue;
                         }
 
-                        var zipEntryStream = zipEntry.Open();
+                        var zipEntryStream = await zipEntry.OpenAsync().ConfigureAwait(false);
                         await using (zipEntryStream.ConfigureAwait(false))
                         {
                             _logger.LogInformation("Restore backup of {Table}", entityType.Type.Name);
@@ -329,7 +329,7 @@ public class BackupService : IBackupService
                             _logger.LogInformation("Begin backup of entity {Table}", entityType.SourceName);
                             var zipEntry = zipArchive.CreateEntry(NormalizePathSeparator(Path.Combine("Database", $"{entityType.SourceName}.json")));
                             var entities = 0;
-                            var zipEntryStream = zipEntry.Open();
+                            var zipEntryStream = await zipEntry.OpenAsync().ConfigureAwait(false);
                             await using (zipEntryStream.ConfigureAwait(false))
                             {
                                 var jsonSerializer = new Utf8JsonWriter(zipEntryStream);
@@ -366,7 +366,7 @@ public class BackupService : IBackupService
                 foreach (var item in Directory.EnumerateFiles(_applicationPaths.ConfigurationDirectoryPath, "*.xml", SearchOption.TopDirectoryOnly)
                              .Union(Directory.EnumerateFiles(_applicationPaths.ConfigurationDirectoryPath, "*.json", SearchOption.TopDirectoryOnly)))
                 {
-                    zipArchive.CreateEntryFromFile(item, NormalizePathSeparator(Path.Combine("Config", Path.GetFileName(item))));
+                    await zipArchive.CreateEntryFromFileAsync(item, NormalizePathSeparator(Path.Combine("Config", Path.GetFileName(item)))).ConfigureAwait(false);
                 }
 
                 void CopyDirectory(string source, string target, string filter = "*")
@@ -380,6 +380,7 @@ public class BackupService : IBackupService
 
                     foreach (var item in Directory.EnumerateFiles(source, filter, SearchOption.AllDirectories))
                     {
+                        // TODO: @bond make async
                         zipArchive.CreateEntryFromFile(item, NormalizePathSeparator(Path.Combine(target, Path.GetRelativePath(source, item))));
                     }
                 }
@@ -405,7 +406,7 @@ public class BackupService : IBackupService
                     CopyDirectory(Path.Combine(_applicationPaths.InternalMetadataPath), Path.Combine("Data", "metadata"));
                 }
 
-                var manifestStream = zipArchive.CreateEntry(ManifestEntryName).Open();
+                var manifestStream = await zipArchive.CreateEntry(ManifestEntryName).OpenAsync().ConfigureAwait(false);
                 await using (manifestStream.ConfigureAwait(false))
                 {
                     await JsonSerializer.SerializeAsync(manifestStream, manifest).ConfigureAwait(false);
@@ -505,7 +506,7 @@ public class BackupService : IBackupService
                 return null;
             }
 
-            var manifestStream = manifestEntry.Open();
+            var manifestStream = await manifestEntry.OpenAsync().ConfigureAwait(false);
             await using (manifestStream.ConfigureAwait(false))
             {
                 return await JsonSerializer.DeserializeAsync<BackupManifest>(manifestStream, _serializerSettings).ConfigureAwait(false);
diff --git a/Jellyfin.Server.Implementations/Jellyfin.Server.Implementations.csproj b/Jellyfin.Server.Implementations/Jellyfin.Server.Implementations.csproj
index 6693ab8db..4f0c37722 100644
--- a/Jellyfin.Server.Implementations/Jellyfin.Server.Implementations.csproj
+++ b/Jellyfin.Server.Implementations/Jellyfin.Server.Implementations.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
@@ -27,7 +27,6 @@
 
   <ItemGroup>
     <PackageReference Include="AsyncKeyedLock" />
-    <PackageReference Include="System.Linq.Async" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
   </ItemGroup>
 
diff --git a/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs b/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
index 8373fd50f..c7bcda442 100644
--- a/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
+++ b/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
@@ -174,7 +174,7 @@ namespace Jellyfin.Server.Extensions
             if (config.KnownProxies.Length == 0)
             {
                 options.ForwardedHeaders = ForwardedHeaders.None;
-                options.KnownNetworks.Clear();
+                options.KnownIPNetworks.Clear();
                 options.KnownProxies.Clear();
             }
             else
@@ -184,7 +184,7 @@ namespace Jellyfin.Server.Extensions
             }
 
             // Only set forward limit if we have some known proxies or some known networks.
-            if (options.KnownProxies.Count != 0 || options.KnownNetworks.Count != 0)
+            if (options.KnownProxies.Count != 0 || options.KnownIPNetworks.Count != 0)
             {
                 options.ForwardLimit = null;
             }
@@ -290,10 +290,7 @@ namespace Jellyfin.Server.Extensions
                 }
                 else if (NetworkUtils.TryParseToSubnet(allowedProxies[i], out var subnet))
                 {
-                    if (subnet is not null)
-                    {
-                        AddIPAddress(config, options, subnet.Prefix, subnet.PrefixLength);
-                    }
+                    AddIPAddress(config, options, subnet.BaseAddress, subnet.PrefixLength);
                 }
                 else if (NetworkUtils.TryParseHost(allowedProxies[i], out var addresses, config.EnableIPv4, config.EnableIPv6))
                 {
@@ -323,7 +320,7 @@ namespace Jellyfin.Server.Extensions
             }
             else
             {
-                options.KnownNetworks.Add(new Microsoft.AspNetCore.HttpOverrides.IPNetwork(addr, prefixLength));
+                options.KnownIPNetworks.Add(new System.Net.IPNetwork(addr, prefixLength));
             }
         }
 
diff --git a/Jellyfin.Server/Jellyfin.Server.csproj b/Jellyfin.Server/Jellyfin.Server.csproj
index 14ab114fb..9f5bf01a0 100644
--- a/Jellyfin.Server/Jellyfin.Server.csproj
+++ b/Jellyfin.Server/Jellyfin.Server.csproj
@@ -8,7 +8,7 @@
   <PropertyGroup>
     <AssemblyName>jellyfin</AssemblyName>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <ServerGarbageCollection>false</ServerGarbageCollection>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
@@ -44,9 +44,6 @@
 
   <ItemGroup>
     <PackageReference Include="CommandLineParser" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.EnvironmentVariables" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Json" />
-    <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks" />
     <PackageReference Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" />
     <PackageReference Include="Morestachio" />
     <PackageReference Include="prometheus-net" />
diff --git a/MediaBrowser.Common/MediaBrowser.Common.csproj b/MediaBrowser.Common/MediaBrowser.Common.csproj
index 5f15f845c..c128c2b6b 100644
--- a/MediaBrowser.Common/MediaBrowser.Common.csproj
+++ b/MediaBrowser.Common/MediaBrowser.Common.csproj
@@ -18,17 +18,12 @@
     <ProjectReference Include="..\MediaBrowser.Model\MediaBrowser.Model.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
-  </ItemGroup>
-
   <ItemGroup>
     <Compile Include="..\SharedVersion.cs" />
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
diff --git a/MediaBrowser.Common/Net/NetworkConstants.cs b/MediaBrowser.Common/Net/NetworkConstants.cs
index ccef5d271..cec996a1a 100644
--- a/MediaBrowser.Common/Net/NetworkConstants.cs
+++ b/MediaBrowser.Common/Net/NetworkConstants.cs
@@ -1,5 +1,4 @@
 using System.Net;
-using IPNetwork = Microsoft.AspNetCore.HttpOverrides.IPNetwork;
 
 namespace MediaBrowser.Common.Net;
 
diff --git a/MediaBrowser.Common/Net/NetworkUtils.cs b/MediaBrowser.Common/Net/NetworkUtils.cs
index 24ed47a81..9c9a35a16 100644
--- a/MediaBrowser.Common/Net/NetworkUtils.cs
+++ b/MediaBrowser.Common/Net/NetworkUtils.cs
@@ -6,7 +6,6 @@ using System.Net;
 using System.Net.Sockets;
 using System.Text.RegularExpressions;
 using Jellyfin.Extensions;
-using IPNetwork = Microsoft.AspNetCore.HttpOverrides.IPNetwork;
 
 namespace MediaBrowser.Common.Net;
 
@@ -196,7 +195,7 @@ public static partial class NetworkUtils
     /// <param name="result">An <see cref="IPNetwork"/>.</param>
     /// <param name="negated">Boolean signaling if negated or not negated values should be parsed.</param>
     /// <returns><c>True</c> if parsing was successful.</returns>
-    public static bool TryParseToSubnet(ReadOnlySpan<char> value, [NotNullWhen(true)] out IPNetwork? result, bool negated = false)
+    public static bool TryParseToSubnet(ReadOnlySpan<char> value, out IPNetwork result, bool negated = false)
     {
         // If multiple IP addresses are in a comma-separated string, the individual addresses may contain leading and/or trailing whitespace
         value = value.Trim();
@@ -210,7 +209,7 @@ public static partial class NetworkUtils
 
         if (isAddressNegated != negated)
         {
-            result = null;
+            result = default;
             return false;
         }
 
@@ -235,7 +234,7 @@ public static partial class NetworkUtils
             }
         }
 
-        result = null;
+        result = default;
         return false;
     }
 
@@ -330,7 +329,7 @@ public static partial class NetworkUtils
     /// <returns>The broadcast address.</returns>
     public static IPAddress GetBroadcastAddress(IPNetwork network)
     {
-        var addressBytes = network.Prefix.GetAddressBytes();
+        var addressBytes = network.BaseAddress.GetAddressBytes();
         uint ipAddress = BitConverter.ToUInt32(addressBytes, 0);
         uint ipMaskV4 = BitConverter.ToUInt32(CidrToMask(network.PrefixLength, AddressFamily.InterNetwork).GetAddressBytes(), 0);
         uint broadCastIPAddress = ipAddress | ~ipMaskV4;
@@ -347,7 +346,6 @@ public static partial class NetworkUtils
     public static bool SubnetContainsAddress(IPNetwork network, IPAddress address)
     {
         ArgumentNullException.ThrowIfNull(address);
-        ArgumentNullException.ThrowIfNull(network);
 
         if (address.IsIPv4MappedToIPv6)
         {
diff --git a/MediaBrowser.Controller/MediaBrowser.Controller.csproj b/MediaBrowser.Controller/MediaBrowser.Controller.csproj
index b5d14e94b..0025080cc 100644
--- a/MediaBrowser.Controller/MediaBrowser.Controller.csproj
+++ b/MediaBrowser.Controller/MediaBrowser.Controller.csproj
@@ -19,9 +19,7 @@
 
   <ItemGroup>
     <PackageReference Include="BitFaster.Caching" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" />
-    <PackageReference Include="System.Threading.Tasks.Dataflow" />
   </ItemGroup>
 
   <ItemGroup>
@@ -36,7 +34,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
diff --git a/MediaBrowser.LocalMetadata/MediaBrowser.LocalMetadata.csproj b/MediaBrowser.LocalMetadata/MediaBrowser.LocalMetadata.csproj
index 8e3c8cf7f..c3c26085c 100644
--- a/MediaBrowser.LocalMetadata/MediaBrowser.LocalMetadata.csproj
+++ b/MediaBrowser.LocalMetadata/MediaBrowser.LocalMetadata.csproj
@@ -11,7 +11,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj b/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj
index be7eeda92..fc11047a7 100644
--- a/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj
+++ b/MediaBrowser.MediaEncoding/MediaBrowser.MediaEncoding.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
@@ -26,7 +26,6 @@
     <PackageReference Include="BDInfo" />
     <PackageReference Include="libse" />
     <PackageReference Include="Microsoft.Extensions.Http" />
-    <PackageReference Include="System.Text.Encoding.CodePages" />
     <PackageReference Include="UTF.Unknown" />
   </ItemGroup>
 
diff --git a/MediaBrowser.Model/MediaBrowser.Model.csproj b/MediaBrowser.Model/MediaBrowser.Model.csproj
index ef025d02d..c655c4ccb 100644
--- a/MediaBrowser.Model/MediaBrowser.Model.csproj
+++ b/MediaBrowser.Model/MediaBrowser.Model.csproj
@@ -14,7 +14,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -37,13 +37,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
     <PackageReference Include="MimeTypes">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="System.Globalization" />
-    <PackageReference Include="System.Text.Json" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/MediaBrowser.Model/Net/IPData.cs b/MediaBrowser.Model/Net/IPData.cs
index c116d883e..e016ffea1 100644
--- a/MediaBrowser.Model/Net/IPData.cs
+++ b/MediaBrowser.Model/Net/IPData.cs
@@ -1,6 +1,5 @@
 using System.Net;
 using System.Net.Sockets;
-using IPNetwork = Microsoft.AspNetCore.HttpOverrides.IPNetwork;
 
 namespace MediaBrowser.Model.Net;
 
@@ -66,9 +65,9 @@ public class IPData
         {
             if (Address.Equals(IPAddress.None))
             {
-                return Subnet.Prefix.AddressFamily.Equals(IPAddress.None)
+                return Subnet.BaseAddress.AddressFamily.Equals(IPAddress.None)
                     ? AddressFamily.Unspecified
-                    : Subnet.Prefix.AddressFamily;
+                    : Subnet.BaseAddress.AddressFamily;
             }
             else
             {
diff --git a/MediaBrowser.Providers/MediaBrowser.Providers.csproj b/MediaBrowser.Providers/MediaBrowser.Providers.csproj
index 34b3104b0..ed0c63b97 100644
--- a/MediaBrowser.Providers/MediaBrowser.Providers.csproj
+++ b/MediaBrowser.Providers/MediaBrowser.Providers.csproj
@@ -18,7 +18,6 @@
     <PackageReference Include="AsyncKeyedLock" />
     <PackageReference Include="LrcParser" />
     <PackageReference Include="MetaBrainz.MusicBrainz" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Caching.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Http" />
     <PackageReference Include="Newtonsoft.Json" />
@@ -28,7 +27,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/MediaBrowser.XbmcMetadata/MediaBrowser.XbmcMetadata.csproj b/MediaBrowser.XbmcMetadata/MediaBrowser.XbmcMetadata.csproj
index b195af96c..cfb3533f3 100644
--- a/MediaBrowser.XbmcMetadata/MediaBrowser.XbmcMetadata.csproj
+++ b/MediaBrowser.XbmcMetadata/MediaBrowser.XbmcMetadata.csproj
@@ -15,7 +15,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/README.md b/README.md
index 9830e8e9c..e546e7f11 100644
--- a/README.md
+++ b/README.md
@@ -39,7 +39,7 @@
 
 ---
 
-Jellyfin is a Free Software Media System that puts you in control of managing and streaming your media. It is an alternative to the proprietary Emby and Plex, to provide media from a dedicated server to end-user devices via multiple apps. Jellyfin is descended from Emby's 3.5.2 release and ported to the .NET platform to enable full cross-platform support. 
+Jellyfin is a Free Software Media System that puts you in control of managing and streaming your media. It is an alternative to the proprietary Emby and Plex, to provide media from a dedicated server to end-user devices via multiple apps. Jellyfin is descended from Emby's 3.5.2 release and ported to the .NET platform to enable full cross-platform support.
 
 There are no strings attached, no premium licenses or features, and no hidden agendas: just a team that wants to build something better and work together to achieve it. We welcome anyone who is interested in joining us in our quest!
 
@@ -133,7 +133,7 @@ A second option is to build the project and then run the resulting executable fi
 
 ```bash
 dotnet build                       # Build the project
-cd Jellyfin.Server/bin/Debug/net9.0 # Change into the build output directory
+cd Jellyfin.Server/bin/Debug/net10.0 # Change into the build output directory
 ```
 
 2. Execute the build output. On Linux, Mac, etc. use `./jellyfin` and on Windows use `jellyfin.exe`.
diff --git a/fuzz/Emby.Server.Implementations.Fuzz/Emby.Server.Implementations.Fuzz.csproj b/fuzz/Emby.Server.Implementations.Fuzz/Emby.Server.Implementations.Fuzz.csproj
index 1373d2fe0..1ac7402f9 100644
--- a/fuzz/Emby.Server.Implementations.Fuzz/Emby.Server.Implementations.Fuzz.csproj
+++ b/fuzz/Emby.Server.Implementations.Fuzz/Emby.Server.Implementations.Fuzz.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/fuzz/Emby.Server.Implementations.Fuzz/fuzz.sh b/fuzz/Emby.Server.Implementations.Fuzz/fuzz.sh
index 8183bb37a..771aa6677 100755
--- a/fuzz/Emby.Server.Implementations.Fuzz/fuzz.sh
+++ b/fuzz/Emby.Server.Implementations.Fuzz/fuzz.sh
@@ -8,4 +8,4 @@ cp bin/Emby.Server.Implementations.dll .
 
 dotnet build
 mkdir -p Findings
-AFL_SKIP_BIN_CHECK=1 afl-fuzz -i "Testcases/$1" -o "Findings/$1" -t 5000 ./bin/Debug/net9.0/Emby.Server.Implementations.Fuzz "$1"
+AFL_SKIP_BIN_CHECK=1 afl-fuzz -i "Testcases/$1" -o "Findings/$1" -t 5000 ./bin/Debug/net10.0/Emby.Server.Implementations.Fuzz "$1"
diff --git a/fuzz/Jellyfin.Api.Fuzz/Jellyfin.Api.Fuzz.csproj b/fuzz/Jellyfin.Api.Fuzz/Jellyfin.Api.Fuzz.csproj
index 04c7be11d..dad2f8e4e 100644
--- a/fuzz/Jellyfin.Api.Fuzz/Jellyfin.Api.Fuzz.csproj
+++ b/fuzz/Jellyfin.Api.Fuzz/Jellyfin.Api.Fuzz.csproj
@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/fuzz/Jellyfin.Api.Fuzz/fuzz.sh b/fuzz/Jellyfin.Api.Fuzz/fuzz.sh
index 15148e1bb..537de905d 100755
--- a/fuzz/Jellyfin.Api.Fuzz/fuzz.sh
+++ b/fuzz/Jellyfin.Api.Fuzz/fuzz.sh
@@ -8,4 +8,4 @@ cp bin/Jellyfin.Api.dll .
 
 dotnet build
 mkdir -p Findings
-AFL_SKIP_BIN_CHECK=1 afl-fuzz -i "Testcases/$1" -o "Findings/$1" -t 5000 ./bin/Debug/net9.0/Jellyfin.Api.Fuzz "$1"
+AFL_SKIP_BIN_CHECK=1 afl-fuzz -i "Testcases/$1" -o "Findings/$1" -t 5000 ./bin/Debug/net10.0/Jellyfin.Api.Fuzz "$1"
diff --git a/global.json b/global.json
index 2e13a6387..867a4cfa0 100644
--- a/global.json
+++ b/global.json
@@ -1,6 +1,6 @@
 {
     "sdk": {
-        "version": "9.0.0",
+        "version": "10.0.0",
         "rollForward": "latestMinor"
     }
 }
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Jellyfin.Database.Implementations.csproj b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Jellyfin.Database.Implementations.csproj
index 28c4972d2..0b29a71cb 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Jellyfin.Database.Implementations.csproj
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Jellyfin.Database.Implementations.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Locking/OptimisticLockBehavior.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Locking/OptimisticLockBehavior.cs
index 7bcc7eeca..76ffa5a9e 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Locking/OptimisticLockBehavior.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Locking/OptimisticLockBehavior.cs
@@ -1,3 +1,5 @@
+#pragma warning disable CA1873
+
 using System;
 using System.Data.Common;
 using System.Linq;
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Locking/PessimisticLockBehavior.cs b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Locking/PessimisticLockBehavior.cs
index 2d6bc6902..404292e8e 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Implementations/Locking/PessimisticLockBehavior.cs
+++ b/src/Jellyfin.Database/Jellyfin.Database.Implementations/Locking/PessimisticLockBehavior.cs
@@ -1,5 +1,6 @@
 #pragma warning disable MT1013 // Releasing lock without guarantee of execution
 #pragma warning disable MT1012 // Acquiring lock without guarantee of releasing
+#pragma warning disable CA1873
 
 using System;
 using System.Data;
diff --git a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Jellyfin.Database.Providers.Sqlite.csproj b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Jellyfin.Database.Providers.Sqlite.csproj
index 03e5fc495..aeee52701 100644
--- a/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Jellyfin.Database.Providers.Sqlite.csproj
+++ b/src/Jellyfin.Database/Jellyfin.Database.Providers.Sqlite/Jellyfin.Database.Providers.Sqlite.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/src/Jellyfin.Drawing.Skia/Jellyfin.Drawing.Skia.csproj b/src/Jellyfin.Drawing.Skia/Jellyfin.Drawing.Skia.csproj
index ba402dfe0..f7c20463f 100644
--- a/src/Jellyfin.Drawing.Skia/Jellyfin.Drawing.Skia.csproj
+++ b/src/Jellyfin.Drawing.Skia/Jellyfin.Drawing.Skia.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <!-- TODO: Remove once we update SkiaSharp > 2.88.5 -->
diff --git a/src/Jellyfin.Drawing/Jellyfin.Drawing.csproj b/src/Jellyfin.Drawing/Jellyfin.Drawing.csproj
index 5f4b3fe8d..a442f7457 100644
--- a/src/Jellyfin.Drawing/Jellyfin.Drawing.csproj
+++ b/src/Jellyfin.Drawing/Jellyfin.Drawing.csproj
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj b/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj
index f52fd014d..9a7cf4aab 100644
--- a/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj
+++ b/src/Jellyfin.Extensions/Jellyfin.Extensions.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
diff --git a/src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj b/src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj
index f04c02504..575441de9 100644
--- a/src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj
+++ b/src/Jellyfin.LiveTv/Jellyfin.LiveTv.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
 
@@ -13,7 +13,6 @@
   <ItemGroup>
     <PackageReference Include="AsyncKeyedLock" />
     <PackageReference Include="Jellyfin.XmlTv" />
-    <PackageReference Include="System.Linq.Async" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/src/Jellyfin.MediaEncoding.Hls/Jellyfin.MediaEncoding.Hls.csproj b/src/Jellyfin.MediaEncoding.Hls/Jellyfin.MediaEncoding.Hls.csproj
index 80b5aa84e..902f51376 100644
--- a/src/Jellyfin.MediaEncoding.Hls/Jellyfin.MediaEncoding.Hls.csproj
+++ b/src/Jellyfin.MediaEncoding.Hls/Jellyfin.MediaEncoding.Hls.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
 
@@ -12,9 +12,6 @@
     <ProjectReference Include="../Jellyfin.MediaEncoding.Keyframes/Jellyfin.MediaEncoding.Keyframes.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" />
-  </ItemGroup>
 
   <ItemGroup>
     <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
diff --git a/src/Jellyfin.MediaEncoding.Keyframes/Jellyfin.MediaEncoding.Keyframes.csproj b/src/Jellyfin.MediaEncoding.Keyframes/Jellyfin.MediaEncoding.Keyframes.csproj
index cc8d942eb..5e7e2090c 100644
--- a/src/Jellyfin.MediaEncoding.Keyframes/Jellyfin.MediaEncoding.Keyframes.csproj
+++ b/src/Jellyfin.MediaEncoding.Keyframes/Jellyfin.MediaEncoding.Keyframes.csproj
@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
 
@@ -22,10 +22,6 @@
     <PackageReference Include="NEbml" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
-  </ItemGroup>
-
   <ItemGroup>
     <AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
       <_Parameter1>Jellyfin.MediaEncoding.Keyframes.Tests</_Parameter1>
diff --git a/src/Jellyfin.Networking/Jellyfin.Networking.csproj b/src/Jellyfin.Networking/Jellyfin.Networking.csproj
index 1a146549d..36b9581a7 100644
--- a/src/Jellyfin.Networking/Jellyfin.Networking.csproj
+++ b/src/Jellyfin.Networking/Jellyfin.Networking.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
diff --git a/src/Jellyfin.Networking/Manager/NetworkManager.cs b/src/Jellyfin.Networking/Manager/NetworkManager.cs
index 126d9f15c..ed7b6dfde 100644
--- a/src/Jellyfin.Networking/Manager/NetworkManager.cs
+++ b/src/Jellyfin.Networking/Manager/NetworkManager.cs
@@ -16,7 +16,6 @@ using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.Logging;
 using static MediaBrowser.Controller.Extensions.ConfigurationExtensions;
 using IConfigurationManager = MediaBrowser.Common.Configuration.IConfigurationManager;
-using IPNetwork = Microsoft.AspNetCore.HttpOverrides.IPNetwork;
 
 namespace Jellyfin.Networking.Manager;
 
@@ -376,7 +375,7 @@ public class NetworkManager : INetworkManager, IDisposable
         if (localNetworkAddresses.Length > 0 && !string.IsNullOrWhiteSpace(localNetworkAddresses[0]))
         {
             var bindAddresses = localNetworkAddresses.Select(p => NetworkUtils.TryParseToSubnet(p, out var network)
-                    ? network.Prefix
+                    ? network.BaseAddress
                     : (interfaces.Where(x => x.Name.Equals(p, StringComparison.OrdinalIgnoreCase))
                         .Select(x => x.Address)
                         .FirstOrDefault() ?? IPAddress.None))
@@ -545,7 +544,7 @@ public class NetworkManager : INetworkManager, IDisposable
                 {
                     foreach (var lan in _lanSubnets)
                     {
-                        var lanPrefix = lan.Prefix;
+                        var lanPrefix = lan.BaseAddress;
                         publishedServerUrls.Add(
                             new PublishedServerUriOverride(
                                 new IPData(lanPrefix, new IPNetwork(lanPrefix, lan.PrefixLength)),
@@ -554,9 +553,9 @@ public class NetworkManager : INetworkManager, IDisposable
                                 false));
                     }
                 }
-                else if (NetworkUtils.TryParseToSubnet(identifier, out var result) && result is not null)
+                else if (NetworkUtils.TryParseToSubnet(identifier, out var result))
                 {
-                    var data = new IPData(result.Prefix, result);
+                    var data = new IPData(result.BaseAddress, result);
                     publishedServerUrls.Add(
                         new PublishedServerUriOverride(
                             data,
@@ -623,7 +622,7 @@ public class NetworkManager : INetworkManager, IDisposable
                 var parts = details.Split(',');
                 if (NetworkUtils.TryParseToSubnet(parts[0], out var subnet))
                 {
-                    var address = subnet.Prefix;
+                    var address = subnet.BaseAddress;
                     var index = int.Parse(parts[1], CultureInfo.InvariantCulture);
                     if (address.AddressFamily == AddressFamily.InterNetwork || address.AddressFamily == AddressFamily.InterNetworkV6)
                     {
@@ -920,7 +919,7 @@ public class NetworkManager : INetworkManager, IDisposable
     {
         if (NetworkUtils.TryParseToSubnet(address, out var subnet))
         {
-            return IsInLocalNetwork(subnet.Prefix);
+            return IsInLocalNetwork(subnet.BaseAddress);
         }
 
         return NetworkUtils.TryParseHost(address, out var addresses, IsIPv4Enabled, IsIPv6Enabled)
@@ -1171,13 +1170,13 @@ public class NetworkManager : INetworkManager, IDisposable
         var logLevel = debug ? LogLevel.Debug : LogLevel.Information;
         if (_logger.IsEnabled(logLevel))
         {
-            _logger.Log(logLevel, "Defined LAN subnets: {Subnets}", _lanSubnets.Select(s => s.Prefix + "/" + s.PrefixLength));
-            _logger.Log(logLevel, "Defined LAN exclusions: {Subnets}", _excludedSubnets.Select(s => s.Prefix + "/" + s.PrefixLength));
-            _logger.Log(logLevel, "Used LAN subnets: {Subnets}", _lanSubnets.Where(s => !_excludedSubnets.Contains(s)).Select(s => s.Prefix + "/" + s.PrefixLength));
+            _logger.Log(logLevel, "Defined LAN subnets: {Subnets}", _lanSubnets.Select(s => s.BaseAddress + "/" + s.PrefixLength));
+            _logger.Log(logLevel, "Defined LAN exclusions: {Subnets}", _excludedSubnets.Select(s => s.BaseAddress + "/" + s.PrefixLength));
+            _logger.Log(logLevel, "Used LAN subnets: {Subnets}", _lanSubnets.Where(s => !_excludedSubnets.Contains(s)).Select(s => s.BaseAddress + "/" + s.PrefixLength));
             _logger.Log(logLevel, "Filtered interface addresses: {Addresses}", _interfaces.OrderByDescending(x => x.AddressFamily == AddressFamily.InterNetwork).Select(x => x.Address));
             _logger.Log(logLevel, "Bind Addresses {Addresses}", GetAllBindInterfaces(false).OrderByDescending(x => x.AddressFamily == AddressFamily.InterNetwork).Select(x => x.Address));
             _logger.Log(logLevel, "Remote IP filter is {Type}", config.IsRemoteIPFilterBlacklist ? "Blocklist" : "Allowlist");
-            _logger.Log(logLevel, "Filtered subnets: {Subnets}", _remoteAddressFilter.Select(s => s.Prefix + "/" + s.PrefixLength));
+            _logger.Log(logLevel, "Filtered subnets: {Subnets}", _remoteAddressFilter.Select(s => s.BaseAddress + "/" + s.PrefixLength));
         }
     }
 }
diff --git a/tests/Directory.Build.props b/tests/Directory.Build.props
index 6b851021f..feec35307 100644
--- a/tests/Directory.Build.props
+++ b/tests/Directory.Build.props
@@ -4,7 +4,7 @@
   <Import Project="$([MSBuild]::GetPathOfFileAbove('Directory.Build.props', '$(MSBuildThisFileDirectory)../'))" />
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <IsPackable>false</IsPackable>
   </PropertyGroup>
 
diff --git a/tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj b/tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj
index 015018910..6b84c4438 100644
--- a/tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj
+++ b/tests/Jellyfin.Api.Tests/Jellyfin.Api.Tests.csproj
@@ -10,7 +10,6 @@
     <PackageReference Include="AutoFixture.AutoMoq" />
     <PackageReference Include="AutoFixture.Xunit2" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" />
-    <PackageReference Include="Microsoft.Extensions.Options" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="xunit" />
     <PackageReference Include="xunit.runner.visualstudio">
diff --git a/tests/Jellyfin.LiveTv.Tests/Jellyfin.LiveTv.Tests.csproj b/tests/Jellyfin.LiveTv.Tests/Jellyfin.LiveTv.Tests.csproj
index fdcf7d61e..bdf6bc383 100644
--- a/tests/Jellyfin.LiveTv.Tests/Jellyfin.LiveTv.Tests.csproj
+++ b/tests/Jellyfin.LiveTv.Tests/Jellyfin.LiveTv.Tests.csproj
@@ -1,6 +1,6 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>
diff --git a/tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj b/tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj
index 8228c0df7..7b0e23788 100644
--- a/tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj
+++ b/tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj
@@ -5,7 +5,6 @@
     <PackageReference Include="AutoFixture.AutoMoq" />
     <PackageReference Include="AutoFixture.Xunit2" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" />
-    <PackageReference Include="Microsoft.Extensions.Options" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="xunit" />
     <PackageReference Include="xunit.runner.visualstudio">
diff --git a/tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj b/tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj
index 5fea805ae..21596e0ed 100644
--- a/tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj
+++ b/tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj
@@ -5,7 +5,6 @@
     <PackageReference Include="AutoFixture.AutoMoq" />
     <PackageReference Include="AutoFixture.Xunit2" />
     <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" />
-    <PackageReference Include="Microsoft.Extensions.Options" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" />
     <PackageReference Include="xunit" />
     <PackageReference Include="xunit.runner.visualstudio">
diff --git a/tests/Jellyfin.Server.Tests/ParseNetworkTests.cs b/tests/Jellyfin.Server.Tests/ParseNetworkTests.cs
index 123266d29..14f4c33b6 100644
--- a/tests/Jellyfin.Server.Tests/ParseNetworkTests.cs
+++ b/tests/Jellyfin.Server.Tests/ParseNetworkTests.cs
@@ -11,7 +11,6 @@ using Microsoft.Extensions.Logging.Abstractions;
 using Moq;
 using Xunit;
 using IConfigurationManager = MediaBrowser.Common.Configuration.IConfigurationManager;
-using IPNetwork = Microsoft.AspNetCore.HttpOverrides.IPNetwork;
 
 namespace Jellyfin.Server.Tests
 {
@@ -87,7 +86,7 @@ namespace Jellyfin.Server.Tests
 
             // Need this here as ::1 and 127.0.0.1 are in them by default.
             options.KnownProxies.Clear();
-            options.KnownNetworks.Clear();
+            options.KnownIPNetworks.Clear();
 
             ApiServiceCollectionExtensions.AddProxyAddresses(settings, hostList, options);
 
@@ -97,10 +96,10 @@ namespace Jellyfin.Server.Tests
                 Assert.True(options.KnownProxies.Contains(item));
             }
 
-            Assert.Equal(knownNetworks.Length, options.KnownNetworks.Count);
+            Assert.Equal(knownNetworks.Length, options.KnownIPNetworks.Count);
             foreach (var item in knownNetworks)
             {
-                Assert.NotNull(options.KnownNetworks.FirstOrDefault(x => x.Prefix.Equals(item.Prefix) && x.PrefixLength == item.PrefixLength));
+                Assert.NotEqual(default, options.KnownIPNetworks.FirstOrDefault(x => x.BaseAddress.Equals(item.BaseAddress) && x.PrefixLength == item.PrefixLength));
             }
         }
 
-- 
cgit v1.2.3


From 1ba8e2c93c2906682050c95957649c20e1b557d9 Mon Sep 17 00:00:00 2001
From: Bond_009 <bond.009@outlook.com>
Date: Sun, 16 Nov 2025 18:59:50 +0100
Subject: Fix tests

---
 .../Extensions/ApiServiceCollectionExtensions.cs   |  2 +-
 MediaBrowser.Common/Net/NetworkUtils.cs            | 27 ++++++++++++----------
 .../LimitedConcurrencyLibraryScheduler.cs          |  2 +-
 src/Jellyfin.Networking/Manager/NetworkManager.cs  | 27 +++++++++-------------
 .../Jellyfin.Networking.Tests/NetworkParseTests.cs |  8 +++----
 5 files changed, 32 insertions(+), 34 deletions(-)

(limited to 'tests')

diff --git a/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs b/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
index c7bcda442..9df24fa0d 100644
--- a/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
+++ b/Jellyfin.Server/Extensions/ApiServiceCollectionExtensions.cs
@@ -290,7 +290,7 @@ namespace Jellyfin.Server.Extensions
                 }
                 else if (NetworkUtils.TryParseToSubnet(allowedProxies[i], out var subnet))
                 {
-                    AddIPAddress(config, options, subnet.BaseAddress, subnet.PrefixLength);
+                    AddIPAddress(config, options, subnet.Address, subnet.Subnet.PrefixLength);
                 }
                 else if (NetworkUtils.TryParseHost(allowedProxies[i], out var addresses, config.EnableIPv4, config.EnableIPv6))
                 {
diff --git a/MediaBrowser.Common/Net/NetworkUtils.cs b/MediaBrowser.Common/Net/NetworkUtils.cs
index 9c9a35a16..5c854b39d 100644
--- a/MediaBrowser.Common/Net/NetworkUtils.cs
+++ b/MediaBrowser.Common/Net/NetworkUtils.cs
@@ -6,6 +6,7 @@ using System.Net;
 using System.Net.Sockets;
 using System.Text.RegularExpressions;
 using Jellyfin.Extensions;
+using MediaBrowser.Model.Net;
 
 namespace MediaBrowser.Common.Net;
 
@@ -166,7 +167,7 @@ public static partial class NetworkUtils
     /// <param name="result">Collection of <see cref="IPNetwork"/>.</param>
     /// <param name="negated">Boolean signaling if negated or not negated values should be parsed.</param>
     /// <returns><c>True</c> if parsing was successful.</returns>
-    public static bool TryParseToSubnets(string[] values, [NotNullWhen(true)] out IReadOnlyList<IPNetwork>? result, bool negated = false)
+    public static bool TryParseToSubnets(string[] values, [NotNullWhen(true)] out IReadOnlyList<IPData>? result, bool negated = false)
     {
         if (values is null || values.Length == 0)
         {
@@ -174,28 +175,28 @@ public static partial class NetworkUtils
             return false;
         }
 
-        var tmpResult = new List<IPNetwork>();
+        List<IPData>? tmpResult = null;
         for (int a = 0; a < values.Length; a++)
         {
             if (TryParseToSubnet(values[a], out var innerResult, negated))
             {
-                tmpResult.Add(innerResult);
+                (tmpResult ??= new()).Add(innerResult);
             }
         }
 
         result = tmpResult;
-        return tmpResult.Count > 0;
+        return result is not null;
     }
 
     /// <summary>
-    /// Try parsing a string into an <see cref="IPNetwork"/>, respecting exclusions.
-    /// Inputs without a subnet mask will be represented as <see cref="IPNetwork"/> with a single IP.
+    /// Try parsing a string into an <see cref="IPData"/>, respecting exclusions.
+    /// Inputs without a subnet mask will be represented as <see cref="IPData"/> with a single IP.
     /// </summary>
     /// <param name="value">Input string to be parsed.</param>
-    /// <param name="result">An <see cref="IPNetwork"/>.</param>
+    /// <param name="result">An <see cref="IPData"/>.</param>
     /// <param name="negated">Boolean signaling if negated or not negated values should be parsed.</param>
     /// <returns><c>True</c> if parsing was successful.</returns>
-    public static bool TryParseToSubnet(ReadOnlySpan<char> value, out IPNetwork result, bool negated = false)
+    public static bool TryParseToSubnet(ReadOnlySpan<char> value, [NotNullWhen(true)] out IPData? result, bool negated = false)
     {
         // If multiple IP addresses are in a comma-separated string, the individual addresses may contain leading and/or trailing whitespace
         value = value.Trim();
@@ -213,10 +214,12 @@ public static partial class NetworkUtils
             return false;
         }
 
-        if (value.Contains('/'))
+        var index = value.IndexOf('/');
+        if (index != -1)
         {
-            if (IPNetwork.TryParse(value, out result))
+            if (IPAddress.TryParse(value[..index], out var address) && IPNetwork.TryParse(value, out var subnet))
             {
+                result = new IPData(address, subnet);
                 return true;
             }
         }
@@ -224,12 +227,12 @@ public static partial class NetworkUtils
         {
             if (address.AddressFamily == AddressFamily.InterNetwork)
             {
-                result = address.Equals(IPAddress.Any) ? NetworkConstants.IPv4Any : new IPNetwork(address, NetworkConstants.MinimumIPv4PrefixSize);
+                result = address.Equals(IPAddress.Any) ? new IPData(IPAddress.Any, NetworkConstants.IPv4Any) : new IPData(address, new IPNetwork(address, NetworkConstants.MinimumIPv4PrefixSize));
                 return true;
             }
             else if (address.AddressFamily == AddressFamily.InterNetworkV6)
             {
-                result = address.Equals(IPAddress.IPv6Any) ? NetworkConstants.IPv6Any : new IPNetwork(address, NetworkConstants.MinimumIPv6PrefixSize);
+                result = address.Equals(IPAddress.IPv6Any) ? new IPData(IPAddress.IPv6Any, NetworkConstants.IPv6Any) : new IPData(address, new IPNetwork(address, NetworkConstants.MinimumIPv6PrefixSize));
                 return true;
             }
         }
diff --git a/MediaBrowser.Controller/LibraryTaskScheduler/LimitedConcurrencyLibraryScheduler.cs b/MediaBrowser.Controller/LibraryTaskScheduler/LimitedConcurrencyLibraryScheduler.cs
index 2811a081a..6da398129 100644
--- a/MediaBrowser.Controller/LibraryTaskScheduler/LimitedConcurrencyLibraryScheduler.cs
+++ b/MediaBrowser.Controller/LibraryTaskScheduler/LimitedConcurrencyLibraryScheduler.cs
@@ -188,7 +188,7 @@ public sealed class LimitedConcurrencyLibraryScheduler : ILimitedConcurrencyLibr
 
             await item.Worker(item.Data).ConfigureAwait(true);
         }
-        catch (System.Exception ex)
+        catch (Exception ex)
         {
             _logger.LogError(ex, "Error while performing a library operation");
         }
diff --git a/src/Jellyfin.Networking/Manager/NetworkManager.cs b/src/Jellyfin.Networking/Manager/NetworkManager.cs
index ed7b6dfde..9127606ba 100644
--- a/src/Jellyfin.Networking/Manager/NetworkManager.cs
+++ b/src/Jellyfin.Networking/Manager/NetworkManager.cs
@@ -340,12 +340,12 @@ public class NetworkManager : INetworkManager, IDisposable
             }
             else
             {
-                _lanSubnets = lanSubnets;
+                _lanSubnets = lanSubnets.Select(x => x.Subnet).ToArray();
             }
 
             _excludedSubnets = NetworkUtils.TryParseToSubnets(subnets, out var excludedSubnets, true)
-                ? excludedSubnets
-                : new List<IPNetwork>();
+                ? excludedSubnets.Select(x => x.Subnet).ToArray()
+                : Array.Empty<IPNetwork>();
         }
     }
 
@@ -375,7 +375,7 @@ public class NetworkManager : INetworkManager, IDisposable
         if (localNetworkAddresses.Length > 0 && !string.IsNullOrWhiteSpace(localNetworkAddresses[0]))
         {
             var bindAddresses = localNetworkAddresses.Select(p => NetworkUtils.TryParseToSubnet(p, out var network)
-                    ? network.BaseAddress
+                    ? network.Address
                     : (interfaces.Where(x => x.Name.Equals(p, StringComparison.OrdinalIgnoreCase))
                         .Select(x => x.Address)
                         .FirstOrDefault() ?? IPAddress.None))
@@ -444,7 +444,7 @@ public class NetworkManager : INetworkManager, IDisposable
                 var remoteFilteredSubnets = remoteIPFilter.Where(x => x.Contains('/', StringComparison.OrdinalIgnoreCase)).ToArray();
                 if (NetworkUtils.TryParseToSubnets(remoteFilteredSubnets, out var remoteAddressFilterResult, false))
                 {
-                    remoteAddressFilter = remoteAddressFilterResult.ToList();
+                    remoteAddressFilter = remoteAddressFilterResult.Select(x => x.Subnet).ToList();
                 }
 
                 // Parse everything else as an IP and construct subnet with a single IP
@@ -555,10 +555,9 @@ public class NetworkManager : INetworkManager, IDisposable
                 }
                 else if (NetworkUtils.TryParseToSubnet(identifier, out var result))
                 {
-                    var data = new IPData(result.BaseAddress, result);
                     publishedServerUrls.Add(
                         new PublishedServerUriOverride(
-                            data,
+                            result,
                             replacement,
                             true,
                             true));
@@ -620,16 +619,12 @@ public class NetworkManager : INetworkManager, IDisposable
             foreach (var details in interfaceList)
             {
                 var parts = details.Split(',');
-                if (NetworkUtils.TryParseToSubnet(parts[0], out var subnet))
+                if (NetworkUtils.TryParseToSubnet(parts[0], out var data))
                 {
-                    var address = subnet.BaseAddress;
-                    var index = int.Parse(parts[1], CultureInfo.InvariantCulture);
-                    if (address.AddressFamily == AddressFamily.InterNetwork || address.AddressFamily == AddressFamily.InterNetworkV6)
+                    data.Index = int.Parse(parts[1], CultureInfo.InvariantCulture);
+                    if (data.AddressFamily == AddressFamily.InterNetwork || data.AddressFamily == AddressFamily.InterNetworkV6)
                     {
-                        var data = new IPData(address, subnet, parts[2])
-                        {
-                            Index = index
-                        };
+                        data.Name = parts[2];
                         interfaces.Add(data);
                     }
                 }
@@ -919,7 +914,7 @@ public class NetworkManager : INetworkManager, IDisposable
     {
         if (NetworkUtils.TryParseToSubnet(address, out var subnet))
         {
-            return IsInLocalNetwork(subnet.BaseAddress);
+            return IsInLocalNetwork(subnet.Address);
         }
 
         return NetworkUtils.TryParseHost(address, out var addresses, IsIPv4Enabled, IsIPv6Enabled)
diff --git a/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs b/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs
index 38208476f..871604514 100644
--- a/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs
+++ b/tests/Jellyfin.Networking.Tests/NetworkParseTests.cs
@@ -113,7 +113,7 @@ namespace Jellyfin.Networking.Tests
         public void IPv4SubnetMaskMatchesValidIPAddress(string netMask, string ipAddress)
         {
             var ipa = IPAddress.Parse(ipAddress);
-            Assert.True(NetworkUtils.TryParseToSubnet(netMask, out var subnet) && subnet.Contains(IPAddress.Parse(ipAddress)));
+            Assert.True(NetworkUtils.TryParseToSubnet(netMask, out var subnet) && subnet.Subnet.Contains(IPAddress.Parse(ipAddress)));
         }
 
         /// <summary>
@@ -131,7 +131,7 @@ namespace Jellyfin.Networking.Tests
         public void IPv4SubnetMaskDoesNotMatchInvalidIPAddress(string netMask, string ipAddress)
         {
             var ipa = IPAddress.Parse(ipAddress);
-            Assert.False(NetworkUtils.TryParseToSubnet(netMask, out var subnet) && subnet.Contains(IPAddress.Parse(ipAddress)));
+            Assert.False(NetworkUtils.TryParseToSubnet(netMask, out var subnet) && subnet.Subnet.Contains(IPAddress.Parse(ipAddress)));
         }
 
         /// <summary>
@@ -147,7 +147,7 @@ namespace Jellyfin.Networking.Tests
         [InlineData("2001:db8:abcd:0012::0/128", "2001:0DB8:ABCD:0012:0000:0000:0000:0000")]
         public void IPv6SubnetMaskMatchesValidIPAddress(string netMask, string ipAddress)
         {
-            Assert.True(NetworkUtils.TryParseToSubnet(netMask, out var subnet) && subnet.Contains(IPAddress.Parse(ipAddress)));
+            Assert.True(NetworkUtils.TryParseToSubnet(netMask, out var subnet) && subnet.Subnet.Contains(IPAddress.Parse(ipAddress)));
         }
 
         [Theory]
@@ -158,7 +158,7 @@ namespace Jellyfin.Networking.Tests
         [InlineData("2001:db8:abcd:0012::0/128", "2001:0DB8:ABCD:0012:0000:0000:0000:0001")]
         public void IPv6SubnetMaskDoesNotMatchInvalidIPAddress(string netMask, string ipAddress)
         {
-            Assert.False(NetworkUtils.TryParseToSubnet(netMask, out var subnet) && subnet.Contains(IPAddress.Parse(ipAddress)));
+            Assert.False(NetworkUtils.TryParseToSubnet(netMask, out var subnet) && subnet.Subnet.Contains(IPAddress.Parse(ipAddress)));
         }
 
         [Theory]
-- 
cgit v1.2.3


From 098e8c6fed6aa1fd873f255b09b58e4780c087d6 Mon Sep 17 00:00:00 2001
From: Bond_009 <bond.009@outlook.com>
Date: Sun, 16 Nov 2025 19:31:45 +0100
Subject: Replace AlphanumericComparator with new
 CompareOptions.NumericOrdering

---
 Emby.Naming/Video/VideoListResolver.cs             |  17 +++-
 .../Sorting/StudioComparer.cs                      |   4 +-
 MediaBrowser.Controller/Sorting/SortExtensions.cs  |   4 +-
 src/Jellyfin.Extensions/AlphanumericComparator.cs  | 112 ---------------------
 .../AlphanumericComparatorTests.cs                 |  34 -------
 5 files changed, 18 insertions(+), 153 deletions(-)
 delete mode 100644 src/Jellyfin.Extensions/AlphanumericComparator.cs
 delete mode 100644 tests/Jellyfin.Extensions.Tests/AlphanumericComparatorTests.cs

(limited to 'tests')

diff --git a/Emby.Naming/Video/VideoListResolver.cs b/Emby.Naming/Video/VideoListResolver.cs
index a3134f3f6..4247fea0e 100644
--- a/Emby.Naming/Video/VideoListResolver.cs
+++ b/Emby.Naming/Video/VideoListResolver.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
@@ -136,19 +137,27 @@ namespace Emby.Naming.Video
 
             if (videos.Count > 1)
             {
-                var groups = videos.GroupBy(x => ResolutionRegex().IsMatch(x.Files[0].FileNameWithoutExtension)).ToList();
+                var groups = videos
+                    .Select(x => (filename: x.Files[0].FileNameWithoutExtension.ToString(), value: x))
+                    .Select(x => (x.filename, resolutionMatch: ResolutionRegex().Match(x.filename), x.value))
+                    .GroupBy(x => x.resolutionMatch.Success)
+                    .ToList();
+
                 videos.Clear();
+
+                StringComparer comparer = StringComparer.Create(CultureInfo.InvariantCulture, CompareOptions.NumericOrdering);
                 foreach (var group in groups)
                 {
                     if (group.Key)
                     {
                         videos.InsertRange(0, group
-                            .OrderByDescending(x => ResolutionRegex().Match(x.Files[0].FileNameWithoutExtension.ToString()).Value, new AlphanumericComparator())
-                            .ThenBy(x => x.Files[0].FileNameWithoutExtension.ToString(), new AlphanumericComparator()));
+                            .OrderByDescending(x => x.resolutionMatch.Value, comparer)
+                            .ThenBy(x => x.filename, comparer)
+                            .Select(x => x.value));
                     }
                     else
                     {
-                        videos.AddRange(group.OrderBy(x => x.Files[0].FileNameWithoutExtension.ToString(), new AlphanumericComparator()));
+                        videos.AddRange(group.OrderBy(x => x.filename, comparer).Select(x => x.value));
                     }
                 }
             }
diff --git a/Emby.Server.Implementations/Sorting/StudioComparer.cs b/Emby.Server.Implementations/Sorting/StudioComparer.cs
index 0edffb783..6d041cf11 100644
--- a/Emby.Server.Implementations/Sorting/StudioComparer.cs
+++ b/Emby.Server.Implementations/Sorting/StudioComparer.cs
@@ -1,11 +1,11 @@
 #pragma warning disable CS1591
 
 using System;
+using System.Globalization;
 using Jellyfin.Data.Enums;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Sorting;
-using MediaBrowser.Model.Querying;
 
 namespace Emby.Server.Implementations.Sorting
 {
@@ -28,7 +28,7 @@ namespace Emby.Server.Implementations.Sorting
             ArgumentNullException.ThrowIfNull(x);
             ArgumentNullException.ThrowIfNull(y);
 
-            return AlphanumericComparator.CompareValues(x.Studios.FirstOrDefault(), y.Studios.FirstOrDefault());
+            return CultureInfo.InvariantCulture.CompareInfo.Compare(x.Studios.FirstOrDefault(), y.Studios.FirstOrDefault(), CompareOptions.NumericOrdering);
         }
     }
 }
diff --git a/MediaBrowser.Controller/Sorting/SortExtensions.cs b/MediaBrowser.Controller/Sorting/SortExtensions.cs
index f9c0d39dd..ec8878dcb 100644
--- a/MediaBrowser.Controller/Sorting/SortExtensions.cs
+++ b/MediaBrowser.Controller/Sorting/SortExtensions.cs
@@ -1,7 +1,9 @@
 #pragma warning disable CS1591
 
 using System;
+using System.Collections;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using Jellyfin.Extensions;
 
@@ -9,7 +11,7 @@ namespace MediaBrowser.Controller.Sorting
 {
     public static class SortExtensions
     {
-        private static readonly AlphanumericComparator _comparer = new AlphanumericComparator();
+        private static readonly StringComparer _comparer = StringComparer.Create(CultureInfo.InvariantCulture, CompareOptions.NumericOrdering);
 
         public static IEnumerable<T> OrderByString<T>(this IEnumerable<T> list, Func<T, string> getName)
         {
diff --git a/src/Jellyfin.Extensions/AlphanumericComparator.cs b/src/Jellyfin.Extensions/AlphanumericComparator.cs
deleted file mode 100644
index 299e2f94a..000000000
--- a/src/Jellyfin.Extensions/AlphanumericComparator.cs
+++ /dev/null
@@ -1,112 +0,0 @@
-using System;
-using System.Collections.Generic;
-
-namespace Jellyfin.Extensions
-{
-    /// <summary>
-    /// Alphanumeric <see cref="IComparer{T}" />.
-    /// </summary>
-    public class AlphanumericComparator : IComparer<string?>
-    {
-        /// <summary>
-        /// Compares two objects and returns a value indicating whether one is less than, equal to, or greater than the other.
-        /// </summary>
-        /// <param name="s1">The first object to compare.</param>
-        /// <param name="s2">The second object to compare.</param>
-        /// <returns>A signed integer that indicates the relative values of <c>x</c> and <c>y</c>.</returns>
-        public static int CompareValues(string? s1, string? s2)
-        {
-            if (s1 is null && s2 is null)
-            {
-                return 0;
-            }
-
-            if (s1 is null)
-            {
-                return -1;
-            }
-
-            if (s2 is null)
-            {
-                return 1;
-            }
-
-            int len1 = s1.Length;
-            int len2 = s2.Length;
-
-            // Early return for empty strings
-            if (len1 == 0 && len2 == 0)
-            {
-                return 0;
-            }
-
-            if (len1 == 0)
-            {
-                return -1;
-            }
-
-            if (len2 == 0)
-            {
-                return 1;
-            }
-
-            int pos1 = 0;
-            int pos2 = 0;
-
-            do
-            {
-                int start1 = pos1;
-                int start2 = pos2;
-
-                bool isNum1 = char.IsDigit(s1[pos1++]);
-                bool isNum2 = char.IsDigit(s2[pos2++]);
-
-                while (pos1 < len1 && char.IsDigit(s1[pos1]) == isNum1)
-                {
-                    pos1++;
-                }
-
-                while (pos2 < len2 && char.IsDigit(s2[pos2]) == isNum2)
-                {
-                    pos2++;
-                }
-
-                var span1 = s1.AsSpan(start1, pos1 - start1);
-                var span2 = s2.AsSpan(start2, pos2 - start2);
-
-                if (isNum1 && isNum2)
-                {
-                    // Trim leading zeros so we can compare the length
-                    // of the strings to find the largest number
-                    span1 = span1.TrimStart('0');
-                    span2 = span2.TrimStart('0');
-                    var span1Len = span1.Length;
-                    var span2Len = span2.Length;
-                    if (span1Len < span2Len)
-                    {
-                        return -1;
-                    }
-
-                    if (span1Len > span2Len)
-                    {
-                        return 1;
-                    }
-                }
-
-                int result = span1.CompareTo(span2, StringComparison.InvariantCulture);
-                if (result != 0)
-                {
-                    return result;
-                }
-            } while (pos1 < len1 && pos2 < len2);
-
-            return len1 - len2;
-        }
-
-        /// <inheritdoc />
-        public int Compare(string? x, string? y)
-        {
-            return CompareValues(x, y);
-        }
-    }
-}
diff --git a/tests/Jellyfin.Extensions.Tests/AlphanumericComparatorTests.cs b/tests/Jellyfin.Extensions.Tests/AlphanumericComparatorTests.cs
deleted file mode 100644
index 105e2a52a..000000000
--- a/tests/Jellyfin.Extensions.Tests/AlphanumericComparatorTests.cs
+++ /dev/null
@@ -1,34 +0,0 @@
-using System;
-using System.Linq;
-using Xunit;
-
-namespace Jellyfin.Extensions.Tests
-{
-    public class AlphanumericComparatorTests
-    {
-        // InlineData is pre-sorted
-        [Theory]
-        [InlineData(null, "", "1", "9", "10", "a", "z")]
-        [InlineData("50F", "100F", "SR9", "SR100")]
-        [InlineData("image-1.jpg", "image-02.jpg", "image-4.jpg", "image-9.jpg", "image-10.jpg", "image-11.jpg", "image-22.jpg")]
-        [InlineData("Hard drive 2GB", "Hard drive 20GB")]
-        [InlineData("b", "e", "è", "ě", "f", "g", "k")]
-        [InlineData("123456789", "123456789a", "abc", "abcd")]
-        [InlineData("12345678912345678912345678913234567891", "123456789123456789123456789132345678912")]
-        [InlineData("12345678912345678912345678913234567891", "12345678912345678912345678913234567891")]
-        [InlineData("12345678912345678912345678913234567891", "12345678912345678912345678913234567892")]
-        [InlineData("12345678912345678912345678913234567891a", "12345678912345678912345678913234567891a")]
-        [InlineData("12345678912345678912345678913234567891a", "12345678912345678912345678913234567891b")]
-        [InlineData("a5", "a11")]
-        [InlineData("a05a", "a5b")]
-        [InlineData("a5a", "a05b")]
-        [InlineData("6xxx", "007asdf")]
-        [InlineData("00042Q", "42s")]
-        public void AlphanumericComparatorTest(params string?[] strings)
-        {
-            var copy = strings.Reverse().ToArray();
-            Array.Sort(copy, new AlphanumericComparator());
-            Assert.Equal(strings, copy);
-        }
-    }
-}
-- 
cgit v1.2.3


From 8d052a6cb17421e6c7774bafc6957029f3c9d4ae Mon Sep 17 00:00:00 2001
From: Abitofevrything <54505189+abitofevrything@users.noreply.github.com>
Date: Sun, 18 Jan 2026 12:17:06 +0100
Subject: Merge pull request #15926 from
 abitofevrything/feat/accurate_hls_seeking

Refactor HLS transcode seeking
---
 Jellyfin.Api/Controllers/AudioController.cs        |  6 ----
 Jellyfin.Api/Controllers/DynamicHlsController.cs   | 36 ----------------------
 .../Controllers/UniversalAudioController.cs        |  8 +----
 Jellyfin.Api/Controllers/VideosController.cs       |  6 ----
 Jellyfin.Api/Helpers/StreamingHelpers.cs           |  2 +-
 .../MediaEncoding/BaseEncodingJobOptions.cs        |  2 --
 .../MediaEncoding/EncodingHelper.cs                | 35 ++++++++++++---------
 .../MediaEncoding/EncodingJobInfo.cs               | 15 ---------
 .../Transcoding/TranscodeManager.cs                |  2 +-
 .../Configuration/EncodingOptions.cs               |  8 +++++
 .../Configuration/HlsAudioSeekStrategy.cs          | 23 ++++++++++++++
 MediaBrowser.Model/Dlna/StreamBuilder.cs           |  1 -
 MediaBrowser.Model/Dlna/StreamInfo.cs              |  8 -----
 MediaBrowser.Model/Dlna/TranscodingProfile.cs      |  4 +--
 .../Jellyfin.Model.Tests/Dlna/LegacyStreamInfo.cs  |  2 --
 .../Test Data/DeviceProfile-AndroidPixel.json      |  3 --
 .../DeviceProfile-AndroidTVExoPlayer.json          |  2 --
 .../Test Data/DeviceProfile-Chrome-NoHLS.json      | 11 -------
 .../Test Data/DeviceProfile-Chrome.json            |  7 ++---
 .../Test Data/DeviceProfile-Firefox.json           |  3 --
 .../DeviceProfile-JellyfinMediaPlayer.json         |  3 --
 .../Test Data/DeviceProfile-LowBandwidth.json      |  3 --
 .../Test Data/DeviceProfile-RokuSSPlus.json        |  6 ----
 .../Test Data/DeviceProfile-RokuSSPlusNext.json    |  6 ----
 .../Test Data/DeviceProfile-SafariNext.json        |  7 ++---
 .../Test Data/DeviceProfile-Tizen3-stereo.json     | 13 --------
 .../Test Data/DeviceProfile-Tizen4-4K-5.1.json     | 13 --------
 .../Test Data/DeviceProfile-TranscodeMedia.json    |  4 ---
 .../Test Data/DeviceProfile-WebOS-23.json          |  4 +--
 .../Test Data/DeviceProfile-Yatse.json             |  3 --
 .../Test Data/DeviceProfile-Yatse2.json            |  3 --
 31 files changed, 61 insertions(+), 188 deletions(-)
 create mode 100644 MediaBrowser.Model/Configuration/HlsAudioSeekStrategy.cs

(limited to 'tests')

diff --git a/Jellyfin.Api/Controllers/AudioController.cs b/Jellyfin.Api/Controllers/AudioController.cs
index e334e1264..4be79ff5a 100644
--- a/Jellyfin.Api/Controllers/AudioController.cs
+++ b/Jellyfin.Api/Controllers/AudioController.cs
@@ -50,7 +50,6 @@ public class AudioController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
@@ -107,7 +106,6 @@ public class AudioController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? audioBitRate,
@@ -159,7 +157,6 @@ public class AudioController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate,
@@ -217,7 +214,6 @@ public class AudioController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
@@ -274,7 +270,6 @@ public class AudioController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? audioBitRate,
@@ -326,7 +321,6 @@ public class AudioController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate,
diff --git a/Jellyfin.Api/Controllers/DynamicHlsController.cs b/Jellyfin.Api/Controllers/DynamicHlsController.cs
index 1e3e2740f..15b04051f 100644
--- a/Jellyfin.Api/Controllers/DynamicHlsController.cs
+++ b/Jellyfin.Api/Controllers/DynamicHlsController.cs
@@ -122,7 +122,6 @@ public class DynamicHlsController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
@@ -182,7 +181,6 @@ public class DynamicHlsController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? audioBitRate,
@@ -238,7 +236,6 @@ public class DynamicHlsController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate,
@@ -364,7 +361,6 @@ public class DynamicHlsController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
@@ -425,7 +421,6 @@ public class DynamicHlsController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? audioBitRate,
@@ -481,7 +476,6 @@ public class DynamicHlsController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate,
@@ -543,7 +537,6 @@ public class DynamicHlsController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="maxStreamingBitrate">Optional. The maximum streaming bitrate.</param>
@@ -601,7 +594,6 @@ public class DynamicHlsController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? maxStreamingBitrate,
@@ -654,7 +646,6 @@ public class DynamicHlsController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate ?? maxStreamingBitrate,
@@ -713,7 +704,6 @@ public class DynamicHlsController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
@@ -771,7 +761,6 @@ public class DynamicHlsController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? audioBitRate,
@@ -826,7 +815,6 @@ public class DynamicHlsController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate,
@@ -887,7 +875,6 @@ public class DynamicHlsController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="maxStreamingBitrate">Optional. The maximum streaming bitrate.</param>
@@ -943,7 +930,6 @@ public class DynamicHlsController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? maxStreamingBitrate,
@@ -996,7 +982,6 @@ public class DynamicHlsController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate ?? maxStreamingBitrate,
@@ -1060,7 +1045,6 @@ public class DynamicHlsController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
@@ -1124,7 +1108,6 @@ public class DynamicHlsController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? audioBitRate,
@@ -1181,7 +1164,6 @@ public class DynamicHlsController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate,
@@ -1247,7 +1229,6 @@ public class DynamicHlsController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="maxStreamingBitrate">Optional. The maximum streaming bitrate.</param>
@@ -1309,7 +1290,6 @@ public class DynamicHlsController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? maxStreamingBitrate,
@@ -1364,7 +1344,6 @@ public class DynamicHlsController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate ?? maxStreamingBitrate,
@@ -1586,16 +1565,6 @@ public class DynamicHlsController : BaseJellyfinApiController
         var videoCodec = _encodingHelper.GetVideoEncoder(state, _encodingOptions);
         var threads = EncodingHelper.GetNumberOfThreads(state, _encodingOptions, videoCodec);
 
-        if (state.BaseRequest.BreakOnNonKeyFrames)
-        {
-            // FIXME: this is actually a workaround, as ideally it really should be the client which decides whether non-keyframe
-            //        breakpoints are supported; but current implementation always uses "ffmpeg input seeking" which is liable
-            //        to produce a missing part of video stream before first keyframe is encountered, which may lead to
-            //        awkward cases like a few starting HLS segments having no video whatsoever, which breaks hls.js
-            _logger.LogInformation("Current HLS implementation doesn't support non-keyframe breaks but one is requested, ignoring that request");
-            state.BaseRequest.BreakOnNonKeyFrames = false;
-        }
-
         var mapArgs = state.IsOutputVideo ? _encodingHelper.GetMapArgs(state) : string.Empty;
 
         var directory = Path.GetDirectoryName(outputPath) ?? throw new ArgumentException($"Provided path ({outputPath}) is not valid.", nameof(outputPath));
@@ -1746,11 +1715,6 @@ public class DynamicHlsController : BaseJellyfinApiController
             var videoCodec = _encodingHelper.GetVideoEncoder(state, _encodingOptions);
             var copyArgs = "-codec:a:0 copy" + bitStreamArgs + strictArgs;
 
-            if (EncodingHelper.IsCopyCodec(videoCodec) && state.EnableBreakOnNonKeyFrames(videoCodec))
-            {
-                return copyArgs + " -copypriorss:a:0 0";
-            }
-
             return copyArgs;
         }
 
diff --git a/Jellyfin.Api/Controllers/UniversalAudioController.cs b/Jellyfin.Api/Controllers/UniversalAudioController.cs
index fd6334703..b1a91ae70 100644
--- a/Jellyfin.Api/Controllers/UniversalAudioController.cs
+++ b/Jellyfin.Api/Controllers/UniversalAudioController.cs
@@ -83,7 +83,6 @@ public class UniversalAudioController : BaseJellyfinApiController
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="enableRemoteMedia">Optional. Whether to enable remote media.</param>
     /// <param name="enableAudioVbrEncoding">Optional. Whether to enable Audio Encoding.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="enableRedirection">Whether to enable redirection. Defaults to true.</param>
     /// <response code="200">Audio stream returned.</response>
     /// <response code="302">Redirected to remote audio stream.</response>
@@ -114,7 +113,6 @@ public class UniversalAudioController : BaseJellyfinApiController
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] bool? enableRemoteMedia,
         [FromQuery] bool enableAudioVbrEncoding = true,
-        [FromQuery] bool breakOnNonKeyFrames = false,
         [FromQuery] bool enableRedirection = true)
     {
         userId = RequestHelpers.GetUserId(User, userId);
@@ -127,7 +125,7 @@ public class UniversalAudioController : BaseJellyfinApiController
             return NotFound();
         }
 
-        var deviceProfile = GetDeviceProfile(container, transcodingContainer, audioCodec, transcodingProtocol, breakOnNonKeyFrames, transcodingAudioChannels, maxAudioSampleRate, maxAudioBitDepth, maxAudioChannels);
+        var deviceProfile = GetDeviceProfile(container, transcodingContainer, audioCodec, transcodingProtocol, transcodingAudioChannels, maxAudioSampleRate, maxAudioBitDepth, maxAudioChannels);
 
         _logger.LogInformation("GetPostedPlaybackInfo profile: {@Profile}", deviceProfile);
 
@@ -208,7 +206,6 @@ public class UniversalAudioController : BaseJellyfinApiController
                 EnableAutoStreamCopy = true,
                 AllowAudioStreamCopy = true,
                 AllowVideoStreamCopy = true,
-                BreakOnNonKeyFrames = breakOnNonKeyFrames,
                 AudioSampleRate = maxAudioSampleRate,
                 MaxAudioChannels = maxAudioChannels,
                 MaxAudioBitDepth = maxAudioBitDepth,
@@ -242,7 +239,6 @@ public class UniversalAudioController : BaseJellyfinApiController
             EnableAutoStreamCopy = true,
             AllowAudioStreamCopy = true,
             AllowVideoStreamCopy = true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames,
             AudioSampleRate = maxAudioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = isStatic ? null : (audioBitRate ?? maxStreamingBitrate),
@@ -263,7 +259,6 @@ public class UniversalAudioController : BaseJellyfinApiController
         string? transcodingContainer,
         string? audioCodec,
         MediaStreamProtocol? transcodingProtocol,
-        bool? breakOnNonKeyFrames,
         int? transcodingAudioChannels,
         int? maxAudioSampleRate,
         int? maxAudioBitDepth,
@@ -298,7 +293,6 @@ public class UniversalAudioController : BaseJellyfinApiController
                 Container = transcodingContainer ?? "mp3",
                 AudioCodec = audioCodec ?? "mp3",
                 Protocol = transcodingProtocol ?? MediaStreamProtocol.http,
-                BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
                 MaxAudioChannels = transcodingAudioChannels?.ToString(CultureInfo.InvariantCulture)
             }
         };
diff --git a/Jellyfin.Api/Controllers/VideosController.cs b/Jellyfin.Api/Controllers/VideosController.cs
index e7c6f23ce..ccf8e9063 100644
--- a/Jellyfin.Api/Controllers/VideosController.cs
+++ b/Jellyfin.Api/Controllers/VideosController.cs
@@ -270,7 +270,6 @@ public class VideosController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
@@ -329,7 +328,6 @@ public class VideosController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? audioBitRate,
@@ -386,7 +384,6 @@ public class VideosController : BaseJellyfinApiController
             EnableAutoStreamCopy = enableAutoStreamCopy ?? true,
             AllowAudioStreamCopy = allowAudioStreamCopy ?? true,
             AllowVideoStreamCopy = allowVideoStreamCopy ?? true,
-            BreakOnNonKeyFrames = breakOnNonKeyFrames ?? false,
             AudioSampleRate = audioSampleRate,
             MaxAudioChannels = maxAudioChannels,
             AudioBitRate = audioBitRate,
@@ -511,7 +508,6 @@ public class VideosController : BaseJellyfinApiController
     /// <param name="enableAutoStreamCopy">Whether or not to allow automatic stream copy if requested values match the original source. Defaults to true.</param>
     /// <param name="allowVideoStreamCopy">Whether or not to allow copying of the video stream url.</param>
     /// <param name="allowAudioStreamCopy">Whether or not to allow copying of the audio stream url.</param>
-    /// <param name="breakOnNonKeyFrames">Optional. Whether to break on non key frames.</param>
     /// <param name="audioSampleRate">Optional. Specify a specific audio sample rate, e.g. 44100.</param>
     /// <param name="maxAudioBitDepth">Optional. The maximum audio bit depth.</param>
     /// <param name="audioBitRate">Optional. Specify an audio bitrate to encode to, e.g. 128000. If omitted this will be left to encoder defaults.</param>
@@ -570,7 +566,6 @@ public class VideosController : BaseJellyfinApiController
         [FromQuery] bool? enableAutoStreamCopy,
         [FromQuery] bool? allowVideoStreamCopy,
         [FromQuery] bool? allowAudioStreamCopy,
-        [FromQuery] bool? breakOnNonKeyFrames,
         [FromQuery] int? audioSampleRate,
         [FromQuery] int? maxAudioBitDepth,
         [FromQuery] int? audioBitRate,
@@ -624,7 +619,6 @@ public class VideosController : BaseJellyfinApiController
             enableAutoStreamCopy,
             allowVideoStreamCopy,
             allowAudioStreamCopy,
-            breakOnNonKeyFrames,
             audioSampleRate,
             maxAudioBitDepth,
             audioBitRate,
diff --git a/Jellyfin.Api/Helpers/StreamingHelpers.cs b/Jellyfin.Api/Helpers/StreamingHelpers.cs
index b3f5b9a80..1e984542e 100644
--- a/Jellyfin.Api/Helpers/StreamingHelpers.cs
+++ b/Jellyfin.Api/Helpers/StreamingHelpers.cs
@@ -201,7 +201,7 @@ public static class StreamingHelpers
             state.OutputVideoCodec = state.Request.VideoCodec;
             state.OutputVideoBitrate = encodingHelper.GetVideoBitrateParamValue(state.VideoRequest, state.VideoStream, state.OutputVideoCodec);
 
-            encodingHelper.TryStreamCopy(state);
+            encodingHelper.TryStreamCopy(state, encodingOptions);
 
             if (!EncodingHelper.IsCopyCodec(state.OutputVideoCodec) && state.OutputVideoBitrate.HasValue)
             {
diff --git a/MediaBrowser.Controller/MediaEncoding/BaseEncodingJobOptions.cs b/MediaBrowser.Controller/MediaEncoding/BaseEncodingJobOptions.cs
index 20f51ddb7..10f2f04af 100644
--- a/MediaBrowser.Controller/MediaEncoding/BaseEncodingJobOptions.cs
+++ b/MediaBrowser.Controller/MediaEncoding/BaseEncodingJobOptions.cs
@@ -43,8 +43,6 @@ namespace MediaBrowser.Controller.MediaEncoding
 
         public bool AllowAudioStreamCopy { get; set; }
 
-        public bool BreakOnNonKeyFrames { get; set; }
-
         /// <summary>
         /// Gets or sets the audio sample rate.
         /// </summary>
diff --git a/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs b/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
index 91d88dc08..11eee1a37 100644
--- a/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
+++ b/MediaBrowser.Controller/MediaEncoding/EncodingHelper.cs
@@ -2914,8 +2914,8 @@ namespace MediaBrowser.Controller.MediaEncoding
 
             if (time > 0)
             {
-                // For direct streaming/remuxing, we seek at the exact position of the keyframe
-                // However, ffmpeg will seek to previous keyframe when the exact time is the input
+                // For direct streaming/remuxing, HLS segments start at keyframes.
+                // However, ffmpeg will seek to previous keyframe when the exact frame time is the input
                 // Workaround this by adding 0.5s offset to the seeking time to get the exact keyframe on most videos.
                 // This will help subtitle syncing.
                 var isHlsRemuxing = state.IsVideoRequest && state.TranscodingType is TranscodingJobType.Hls && IsCopyCodec(state.OutputVideoCodec);
@@ -2932,17 +2932,16 @@ namespace MediaBrowser.Controller.MediaEncoding
 
                 if (state.IsVideoRequest)
                 {
-                    var outputVideoCodec = GetVideoEncoder(state, options);
-                    var segmentFormat = GetSegmentFileExtension(segmentContainer).TrimStart('.');
-
-                    // Important: If this is ever re-enabled, make sure not to use it with wtv because it breaks seeking
-                    // Disable -noaccurate_seek on mpegts container due to the timestamps issue on some clients,
-                    // but it's still required for fMP4 container otherwise the audio can't be synced to the video.
-                    if (!string.Equals(state.InputContainer, "wtv", StringComparison.OrdinalIgnoreCase)
-                        && !string.Equals(segmentFormat, "ts", StringComparison.OrdinalIgnoreCase)
-                        && state.TranscodingType != TranscodingJobType.Progressive
-                        && !state.EnableBreakOnNonKeyFrames(outputVideoCodec)
-                        && (state.BaseRequest.StartTimeTicks ?? 0) > 0)
+                    // If we are remuxing, then the copied stream cannot be seeked accurately (it will seek to the nearest
+                    // keyframe). If we are using fMP4, then force all other streams to use the same inaccurate seeking to
+                    // avoid A/V sync issues which cause playback issues on some devices.
+                    // When remuxing video, the segment start times correspond to key frames in the source stream, so this
+                    // option shouldn't change the seeked point that much.
+                    // Important: make sure not to use it with wtv because it breaks seeking
+                    if (state.TranscodingType is TranscodingJobType.Hls
+                        && string.Equals(segmentContainer, "mp4", StringComparison.OrdinalIgnoreCase)
+                        && (IsCopyCodec(state.OutputVideoCodec) || IsCopyCodec(state.OutputAudioCodec))
+                        && !string.Equals(state.InputContainer, "wtv", StringComparison.OrdinalIgnoreCase))
                     {
                         seekParam += " -noaccurate_seek";
                     }
@@ -7084,7 +7083,7 @@ namespace MediaBrowser.Controller.MediaEncoding
         }
 
 #nullable disable
-        public void TryStreamCopy(EncodingJobInfo state)
+        public void TryStreamCopy(EncodingJobInfo state, EncodingOptions options)
         {
             if (state.VideoStream is not null && CanStreamCopyVideo(state, state.VideoStream))
             {
@@ -7101,8 +7100,14 @@ namespace MediaBrowser.Controller.MediaEncoding
                 }
             }
 
+            var preventHlsAudioCopy = state.TranscodingType is TranscodingJobType.Hls
+                && state.VideoStream is not null
+                && !IsCopyCodec(state.OutputVideoCodec)
+                && options.HlsAudioSeekStrategy is HlsAudioSeekStrategy.TranscodeAudio;
+
             if (state.AudioStream is not null
-                && CanStreamCopyAudio(state, state.AudioStream, state.SupportedAudioCodecs))
+                && CanStreamCopyAudio(state, state.AudioStream, state.SupportedAudioCodecs)
+                && !preventHlsAudioCopy)
             {
                 state.OutputAudioCodec = "copy";
             }
diff --git a/MediaBrowser.Controller/MediaEncoding/EncodingJobInfo.cs b/MediaBrowser.Controller/MediaEncoding/EncodingJobInfo.cs
index 43680f5c0..7d0384ef2 100644
--- a/MediaBrowser.Controller/MediaEncoding/EncodingJobInfo.cs
+++ b/MediaBrowser.Controller/MediaEncoding/EncodingJobInfo.cs
@@ -515,21 +515,6 @@ namespace MediaBrowser.Controller.MediaEncoding
 
         public int HlsListSize => 0;
 
-        public bool EnableBreakOnNonKeyFrames(string videoCodec)
-        {
-            if (TranscodingType != TranscodingJobType.Progressive)
-            {
-                if (IsSegmentedLiveStream)
-                {
-                    return false;
-                }
-
-                return BaseRequest.BreakOnNonKeyFrames && EncodingHelper.IsCopyCodec(videoCodec);
-            }
-
-            return false;
-        }
-
         private int? GetMediaStreamCount(MediaStreamType type, int limit)
         {
             var count = MediaSource.GetStreamCount(type);
diff --git a/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs b/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs
index 2fd054f11..defd855ec 100644
--- a/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs
+++ b/MediaBrowser.MediaEncoding/Transcoding/TranscodeManager.cs
@@ -673,7 +673,7 @@ public sealed class TranscodeManager : ITranscodeManager, IDisposable
 
             if (state.VideoRequest is not null)
             {
-                _encodingHelper.TryStreamCopy(state);
+                _encodingHelper.TryStreamCopy(state, encodingOptions);
             }
         }
 
diff --git a/MediaBrowser.Model/Configuration/EncodingOptions.cs b/MediaBrowser.Model/Configuration/EncodingOptions.cs
index f7f386d28..98fc2e632 100644
--- a/MediaBrowser.Model/Configuration/EncodingOptions.cs
+++ b/MediaBrowser.Model/Configuration/EncodingOptions.cs
@@ -1,6 +1,7 @@
 #pragma warning disable CA1819 // XML serialization handles collections improperly, so we need to use arrays
 
 #nullable disable
+using System.ComponentModel;
 using MediaBrowser.Model.Entities;
 
 namespace MediaBrowser.Model.Configuration;
@@ -60,6 +61,7 @@ public class EncodingOptions
         SubtitleExtractionTimeoutMinutes = 30;
         AllowOnDemandMetadataBasedKeyframeExtractionForExtensions = ["mkv"];
         HardwareDecodingCodecs = ["h264", "vc1"];
+        HlsAudioSeekStrategy = HlsAudioSeekStrategy.DisableAccurateSeek;
     }
 
     /// <summary>
@@ -301,4 +303,10 @@ public class EncodingOptions
     /// Gets or sets the file extensions on-demand metadata based keyframe extraction is enabled for.
     /// </summary>
     public string[] AllowOnDemandMetadataBasedKeyframeExtractionForExtensions { get; set; }
+
+    /// <summary>
+    /// Gets or sets the method used for audio seeking in HLS.
+    /// </summary>
+    [DefaultValue(HlsAudioSeekStrategy.DisableAccurateSeek)]
+    public HlsAudioSeekStrategy HlsAudioSeekStrategy { get; set; }
 }
diff --git a/MediaBrowser.Model/Configuration/HlsAudioSeekStrategy.cs b/MediaBrowser.Model/Configuration/HlsAudioSeekStrategy.cs
new file mode 100644
index 000000000..49feeb435
--- /dev/null
+++ b/MediaBrowser.Model/Configuration/HlsAudioSeekStrategy.cs
@@ -0,0 +1,23 @@
+namespace MediaBrowser.Model.Configuration
+{
+    /// <summary>
+    /// An enum representing the options to seek the input audio stream when
+    /// transcoding HLS segments.
+    /// </summary>
+    public enum HlsAudioSeekStrategy
+    {
+        /// <summary>
+        /// If the video stream is transcoded and the audio stream is copied,
+        /// seek the video stream to the same keyframe as the audio stream. The
+        /// resulting timestamps in the output streams may be inaccurate.
+        /// </summary>
+        DisableAccurateSeek = 0,
+
+        /// <summary>
+        /// Prevent audio streams from being copied if the video stream is transcoded.
+        /// The resulting timestamps will be accurate, but additional audio transcoding
+        /// overhead will be incurred.
+        /// </summary>
+        TranscodeAudio = 1,
+    }
+}
diff --git a/MediaBrowser.Model/Dlna/StreamBuilder.cs b/MediaBrowser.Model/Dlna/StreamBuilder.cs
index 61e04a813..42cb208d0 100644
--- a/MediaBrowser.Model/Dlna/StreamBuilder.cs
+++ b/MediaBrowser.Model/Dlna/StreamBuilder.cs
@@ -610,7 +610,6 @@ namespace MediaBrowser.Model.Dlna
             playlistItem.EnableSubtitlesInManifest = transcodingProfile.EnableSubtitlesInManifest;
             playlistItem.EnableMpegtsM2TsMode = transcodingProfile.EnableMpegtsM2TsMode;
 
-            playlistItem.BreakOnNonKeyFrames = transcodingProfile.BreakOnNonKeyFrames;
             playlistItem.EnableAudioVbrEncoding = transcodingProfile.EnableAudioVbrEncoding;
 
             if (transcodingProfile.MinSegments > 0)
diff --git a/MediaBrowser.Model/Dlna/StreamInfo.cs b/MediaBrowser.Model/Dlna/StreamInfo.cs
index 92404de50..9edb4115c 100644
--- a/MediaBrowser.Model/Dlna/StreamInfo.cs
+++ b/MediaBrowser.Model/Dlna/StreamInfo.cs
@@ -86,11 +86,6 @@ public class StreamInfo
     /// <value>The minimum segments count.</value>
     public int? MinSegments { get; set; }
 
-    /// <summary>
-    /// Gets or sets a value indicating whether the stream can be broken on non-keyframes.
-    /// </summary>
-    public bool BreakOnNonKeyFrames { get; set; }
-
     /// <summary>
     /// Gets or sets a value indicating whether the stream requires AVC.
     /// </summary>
@@ -1018,9 +1013,6 @@ public class StreamInfo
                 sb.Append("&MinSegments=");
                 sb.Append(MinSegments.Value.ToString(CultureInfo.InvariantCulture));
             }
-
-            sb.Append("&BreakOnNonKeyFrames=");
-            sb.Append(BreakOnNonKeyFrames.ToString(CultureInfo.InvariantCulture));
         }
         else
         {
diff --git a/MediaBrowser.Model/Dlna/TranscodingProfile.cs b/MediaBrowser.Model/Dlna/TranscodingProfile.cs
index 5797d4250..f49b24976 100644
--- a/MediaBrowser.Model/Dlna/TranscodingProfile.cs
+++ b/MediaBrowser.Model/Dlna/TranscodingProfile.cs
@@ -41,7 +41,6 @@ public class TranscodingProfile
         MaxAudioChannels = other.MaxAudioChannels;
         MinSegments = other.MinSegments;
         SegmentLength = other.SegmentLength;
-        BreakOnNonKeyFrames = other.BreakOnNonKeyFrames;
         Conditions = other.Conditions;
         EnableAudioVbrEncoding = other.EnableAudioVbrEncoding;
     }
@@ -143,7 +142,8 @@ public class TranscodingProfile
     /// </summary>
     [DefaultValue(false)]
     [XmlAttribute("breakOnNonKeyFrames")]
-    public bool BreakOnNonKeyFrames { get; set; }
+    [Obsolete("This is always false")]
+    public bool? BreakOnNonKeyFrames { get; set; }
 
     /// <summary>
     /// Gets or sets the profile conditions.
diff --git a/tests/Jellyfin.Model.Tests/Dlna/LegacyStreamInfo.cs b/tests/Jellyfin.Model.Tests/Dlna/LegacyStreamInfo.cs
index e32baef55..6436d7d0e 100644
--- a/tests/Jellyfin.Model.Tests/Dlna/LegacyStreamInfo.cs
+++ b/tests/Jellyfin.Model.Tests/Dlna/LegacyStreamInfo.cs
@@ -134,8 +134,6 @@ public class LegacyStreamInfo : StreamInfo
             {
                 list.Add(new NameValuePair("MinSegments", item.MinSegments.Value.ToString(CultureInfo.InvariantCulture)));
             }
-
-            list.Add(new NameValuePair("BreakOnNonKeyFrames", item.BreakOnNonKeyFrames.ToString(CultureInfo.InvariantCulture)));
         }
         else
         {
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-AndroidPixel.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-AndroidPixel.json
index 68ce3ea4a..643ff2638 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-AndroidPixel.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-AndroidPixel.json	
@@ -152,7 +152,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -169,7 +168,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -185,7 +183,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-AndroidTVExoPlayer.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-AndroidTVExoPlayer.json
index 3d3968268..44f63f384 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-AndroidTVExoPlayer.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-AndroidTVExoPlayer.json	
@@ -130,7 +130,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -146,7 +145,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Chrome-NoHLS.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Chrome-NoHLS.json
index 5d1f5f162..f1fc9e0db 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Chrome-NoHLS.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Chrome-NoHLS.json	
@@ -127,7 +127,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -144,7 +143,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -161,7 +159,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -178,7 +175,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -195,7 +191,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -212,7 +207,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -229,7 +223,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -246,7 +239,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -263,7 +255,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -281,7 +272,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -298,7 +288,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Chrome.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Chrome.json
index e2f75b569..7e37a6236 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Chrome.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Chrome.json	
@@ -107,7 +107,6 @@
             "Protocol": "hls",
             "MaxAudioChannels": "2",
             "MinSegments": "2",
-            "BreakOnNonKeyFrames": true,
             "EnableAudioVbrEncoding": true
         },
         {
@@ -182,8 +181,7 @@
             "Context": "Streaming",
             "Protocol": "hls",
             "MaxAudioChannels": "2",
-            "MinSegments": "2",
-            "BreakOnNonKeyFrames": true
+            "MinSegments": "2"
         },
         {
             "Container": "ts",
@@ -193,8 +191,7 @@
             "Context": "Streaming",
             "Protocol": "hls",
             "MaxAudioChannels": "2",
-            "MinSegments": "2",
-            "BreakOnNonKeyFrames": true
+            "MinSegments": "2"
         }
     ],
     "ContainerProfiles": [],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Firefox.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Firefox.json
index 21ae7e5cb..4380d80ef 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Firefox.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Firefox.json	
@@ -95,7 +95,6 @@
     "TranscodingProfiles": [
         {
             "AudioCodec": "aac",
-            "BreakOnNonKeyFrames": true,
             "Container": "mp4",
             "Context": "Streaming",
             "EnableAudioVbrEncoding": true,
@@ -170,7 +169,6 @@
         },
         {
             "AudioCodec": "aac,mp2,opus,flac",
-            "BreakOnNonKeyFrames": true,
             "Container": "mp4",
             "Context": "Streaming",
             "MaxAudioChannels": "2",
@@ -181,7 +179,6 @@
         },
         {
             "AudioCodec": "aac,mp3,mp2",
-            "BreakOnNonKeyFrames": true,
             "Container": "ts",
             "Context": "Streaming",
             "MaxAudioChannels": "2",
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-JellyfinMediaPlayer.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-JellyfinMediaPlayer.json
index da9a1a4ad..cca1c16ee 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-JellyfinMediaPlayer.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-JellyfinMediaPlayer.json	
@@ -30,7 +30,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -48,7 +47,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -62,7 +60,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-LowBandwidth.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-LowBandwidth.json
index 82b73fb0f..b7cd170b9 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-LowBandwidth.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-LowBandwidth.json	
@@ -30,7 +30,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -48,7 +47,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -62,7 +60,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-RokuSSPlus.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-RokuSSPlus.json
index 37b923558..b823ac4b8 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-RokuSSPlus.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-RokuSSPlus.json	
@@ -49,7 +49,6 @@
             "MaxAudioChannels": " 2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -66,7 +65,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -83,7 +81,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -100,7 +97,6 @@
             "MaxAudioChannels": " 2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -118,7 +114,6 @@
             "MaxAudioChannels": " 2",
             "MinSegments": 1,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -135,7 +130,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-RokuSSPlusNext.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-RokuSSPlusNext.json
index 542bf6370..708ff73c4 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-RokuSSPlusNext.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-RokuSSPlusNext.json	
@@ -49,7 +49,6 @@
             "MaxAudioChannels": " 2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -66,7 +65,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -83,7 +81,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -100,7 +97,6 @@
             "MaxAudioChannels": " 2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -118,7 +114,6 @@
             "MaxAudioChannels": " 2",
             "MinSegments": 1,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -135,7 +130,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-SafariNext.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-SafariNext.json
index f61d0e36b..10382fa82 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-SafariNext.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-SafariNext.json	
@@ -114,7 +114,6 @@
             "Protocol": "hls",
             "MaxAudioChannels": "6",
             "MinSegments": "2",
-            "BreakOnNonKeyFrames": true,
             "EnableAudioVbrEncoding": true
         },
         {
@@ -173,8 +172,7 @@
             "Context": "Streaming",
             "Protocol": "hls",
             "MaxAudioChannels": "2",
-            "MinSegments": "2",
-            "BreakOnNonKeyFrames": true
+            "MinSegments": "2"
         },
         {
             "Container": "ts",
@@ -184,8 +182,7 @@
             "Context": "Streaming",
             "Protocol": "hls",
             "MaxAudioChannels": "2",
-            "MinSegments": "2",
-            "BreakOnNonKeyFrames": true
+            "MinSegments": "2"
         }
     ],
     "ContainerProfiles": [],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Tizen3-stereo.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Tizen3-stereo.json
index 9d43d2166..3625b099c 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Tizen3-stereo.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Tizen3-stereo.json	
@@ -165,7 +165,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 1,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": true,
             "$type": "TranscodingProfile"
         },
         {
@@ -182,7 +181,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -199,7 +197,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -216,7 +213,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -233,7 +229,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -250,7 +245,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -267,7 +261,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -284,7 +277,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -301,7 +293,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -319,7 +310,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "Conditions": [
                 {
                     "Condition": "LessThanEqual",
@@ -346,7 +336,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 1,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "Conditions": [
                 {
                     "Condition": "LessThanEqual",
@@ -373,7 +362,6 @@
             "MaxAudioChannels": "2",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "Conditions": [
                 {
                     "Condition": "LessThanEqual",
@@ -399,7 +387,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "Conditions": [
                 {
                     "Condition": "LessThanEqual",
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Tizen4-4K-5.1.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Tizen4-4K-5.1.json
index 3859ef994..deee650b2 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Tizen4-4K-5.1.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Tizen4-4K-5.1.json	
@@ -165,7 +165,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 1,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": true,
             "$type": "TranscodingProfile"
         },
         {
@@ -182,7 +181,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -199,7 +197,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -216,7 +213,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -233,7 +229,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -250,7 +245,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -267,7 +261,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -284,7 +277,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -301,7 +293,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -319,7 +310,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "Conditions": [
                 {
                     "Condition": "LessThanEqual",
@@ -346,7 +336,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 1,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "Conditions": [
                 {
                     "Condition": "LessThanEqual",
@@ -373,7 +362,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "Conditions": [
                 {
                     "Condition": "LessThanEqual",
@@ -399,7 +387,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "Conditions": [
                 {
                     "Condition": "LessThanEqual",
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-TranscodeMedia.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-TranscodeMedia.json
index 9fc1ae6bb..38de51b04 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-TranscodeMedia.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-TranscodeMedia.json	
@@ -16,7 +16,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -28,7 +27,6 @@
             "Protocol": "hls",
             "MaxAudioChannels": "2",
             "MinSegments": "2",
-            "BreakOnNonKeyFrames": true,
             "$type": "TranscodingProfile"
         },
         {
@@ -40,7 +38,6 @@
             "Protocol": "hls",
             "MaxAudioChannels": "2",
             "MinSegments": "2",
-            "BreakOnNonKeyFrames": true,
             "$type": "TranscodingProfile"
         },
         {
@@ -64,7 +61,6 @@
             "EnableSubtitlesInManifest": false,
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-WebOS-23.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-WebOS-23.json
index 094b0723b..3ff11a684 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-WebOS-23.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-WebOS-23.json	
@@ -135,7 +135,6 @@
             "Protocol": "hls",
             "MaxAudioChannels": "6",
             "MinSegments": "1",
-            "BreakOnNonKeyFrames": false,
             "EnableAudioVbrEncoding": true
         },
         {
@@ -210,8 +209,7 @@
             "Context": "Streaming",
             "Protocol": "hls",
             "MaxAudioChannels": "6",
-            "MinSegments": "1",
-            "BreakOnNonKeyFrames": false
+            "MinSegments": "1"
         }
     ],
     "ContainerProfiles": [],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Yatse.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Yatse.json
index 256c8dc2f..838a1f920 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Yatse.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Yatse.json	
@@ -52,7 +52,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -70,7 +69,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -88,7 +86,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
diff --git a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Yatse2.json b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Yatse2.json
index 256c8dc2f..838a1f920 100644
--- a/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Yatse2.json	
+++ b/tests/Jellyfin.Model.Tests/Test Data/DeviceProfile-Yatse2.json	
@@ -52,7 +52,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -70,7 +69,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         },
         {
@@ -88,7 +86,6 @@
             "MaxAudioChannels": "6",
             "MinSegments": 0,
             "SegmentLength": 0,
-            "BreakOnNonKeyFrames": false,
             "$type": "TranscodingProfile"
         }
     ],
-- 
cgit v1.2.3


From c9b7c5bb5665d2eb02381fa12dcce786fee9ae3d Mon Sep 17 00:00:00 2001
From: theguymadmax <171496228+theguymadmax@users.noreply.github.com>
Date: Sun, 18 Jan 2026 11:30:43 -0500
Subject: Backport pull request #16029 from jellyfin/release-10.11.z

Skip hidden directories and .ignore paths in library monitoring

Original-merge: 2cb7fb52d2221d9daa39206089b578c2c0fcb549

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Bond_009 <bond.009@outlook.com>
---
 Emby.Server.Implementations/IO/LibraryMonitor.cs                    | 6 ++++++
 Emby.Server.Implementations/Library/IgnorePatterns.cs               | 1 +
 .../Library/IgnorePatternsTests.cs                                  | 4 ++--
 3 files changed, 9 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/Emby.Server.Implementations/IO/LibraryMonitor.cs b/Emby.Server.Implementations/IO/LibraryMonitor.cs
index d87ad729e..7cff2a25b 100644
--- a/Emby.Server.Implementations/IO/LibraryMonitor.cs
+++ b/Emby.Server.Implementations/IO/LibraryMonitor.cs
@@ -352,6 +352,12 @@ namespace Emby.Server.Implementations.IO
                 return;
             }
 
+            var fileInfo = _fileSystem.GetFileSystemInfo(path);
+            if (DotIgnoreIgnoreRule.IsIgnored(fileInfo, null))
+            {
+                return;
+            }
+
             // Ignore certain files, If the parent of an ignored path has a change event, ignore that too
             foreach (var i in _tempIgnoredPaths.Keys)
             {
diff --git a/Emby.Server.Implementations/Library/IgnorePatterns.cs b/Emby.Server.Implementations/Library/IgnorePatterns.cs
index fe3a1ce61..5fac2f6b0 100644
--- a/Emby.Server.Implementations/Library/IgnorePatterns.cs
+++ b/Emby.Server.Implementations/Library/IgnorePatterns.cs
@@ -83,6 +83,7 @@ namespace Emby.Server.Implementations.Library
 
             // Unix hidden files
             "**/.*",
+            "**/.*/**",
 
             // Mac - if you ever remove the above.
             // "**/._*",
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/IgnorePatternsTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/IgnorePatternsTests.cs
index 07061cfc7..4cb6cb960 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/IgnorePatternsTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/IgnorePatternsTests.cs
@@ -19,7 +19,7 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("/media/movies/#recycle", true)]
         [InlineData("thumbs.db", true)]
         [InlineData(@"C:\media\movies\movie.avi", false)]
-        [InlineData("/media/.hiddendir/file.mp4", false)]
+        [InlineData("/media/.hiddendir/file.mp4", true)]
         [InlineData("/media/dir/.hiddenfile.mp4", true)]
         [InlineData("/media/dir/._macjunk.mp4", true)]
         [InlineData("/volume1/video/Series/@eaDir", true)]
@@ -32,7 +32,7 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("/media/music/Foo B.A.R", false)]
         [InlineData("/media/music/Foo B.A.R.", false)]
         [InlineData("/movies/.zfs/snapshot/AutoM-2023-09", true)]
-        public void PathIgnored(string path, bool expected)
+        public void PathIgnored(string path,  bool expected)
         {
             Assert.Equal(expected, IgnorePatterns.ShouldIgnore(path));
         }
-- 
cgit v1.2.3


From 0c274af72c1d223c0fea7f4f4ac99e04f1e1e904 Mon Sep 17 00:00:00 2001
From: theguymadmax <171496228+theguymadmax@users.noreply.github.com>
Date: Wed, 28 Jan 2026 12:11:28 -0500
Subject: Backport pull request #16077 from jellyfin/release-10.11.z

Revert hidden directory ignore pattern

Original-merge: 644327eb762a907328c68ab9f5d61a151cd96897

Merged-by: crobibero <cody@robibe.ro>

Backported-by: Bond_009 <bond.009@outlook.com>
---
 Emby.Server.Implementations/Library/IgnorePatterns.cs                | 5 ++++-
 .../Library/IgnorePatternsTests.cs                                   | 4 ++--
 2 files changed, 6 insertions(+), 3 deletions(-)

(limited to 'tests')

diff --git a/Emby.Server.Implementations/Library/IgnorePatterns.cs b/Emby.Server.Implementations/Library/IgnorePatterns.cs
index 5fac2f6b0..59ccb9e2c 100644
--- a/Emby.Server.Implementations/Library/IgnorePatterns.cs
+++ b/Emby.Server.Implementations/Library/IgnorePatterns.cs
@@ -50,6 +50,10 @@ namespace Emby.Server.Implementations.Library
             "**/lost+found",
             "**/subs/**",
             "**/subs",
+            "**/.snapshots/**",
+            "**/.snapshots",
+            "**/.snapshot/**",
+            "**/.snapshot",
 
             // Trickplay files
             "**/*.trickplay",
@@ -83,7 +87,6 @@ namespace Emby.Server.Implementations.Library
 
             // Unix hidden files
             "**/.*",
-            "**/.*/**",
 
             // Mac - if you ever remove the above.
             // "**/._*",
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/IgnorePatternsTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/IgnorePatternsTests.cs
index 4cb6cb960..07061cfc7 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/IgnorePatternsTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/IgnorePatternsTests.cs
@@ -19,7 +19,7 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("/media/movies/#recycle", true)]
         [InlineData("thumbs.db", true)]
         [InlineData(@"C:\media\movies\movie.avi", false)]
-        [InlineData("/media/.hiddendir/file.mp4", true)]
+        [InlineData("/media/.hiddendir/file.mp4", false)]
         [InlineData("/media/dir/.hiddenfile.mp4", true)]
         [InlineData("/media/dir/._macjunk.mp4", true)]
         [InlineData("/volume1/video/Series/@eaDir", true)]
@@ -32,7 +32,7 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("/media/music/Foo B.A.R", false)]
         [InlineData("/media/music/Foo B.A.R.", false)]
         [InlineData("/movies/.zfs/snapshot/AutoM-2023-09", true)]
-        public void PathIgnored(string path,  bool expected)
+        public void PathIgnored(string path, bool expected)
         {
             Assert.Equal(expected, IgnorePatterns.ShouldIgnore(path));
         }
-- 
cgit v1.2.3


From 8083ab78b558e4081caf4fd321e5ad8f74844f3e Mon Sep 17 00:00:00 2001
From: Bond-009 <bond.009@outlook.com>
Date: Mon, 2 Feb 2026 20:46:28 +0100
Subject: Fix tests

---
 .../Library/PathExtensionsTests.cs                                    | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'tests')

diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
index 74cd303ba..650d67b19 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
@@ -26,8 +26,8 @@ namespace Jellyfin.Server.Implementations.Tests.Library
         [InlineData("Superman: Red Son [providerb id=5]", "providerb id", "5")]
         [InlineData("Superman: Red Son [tmdbid=3]", "tmdbid", "3")]
         [InlineData("Superman: Red Son [tvdbid-6]", "tvdbid", "6")]
-        [InlineData("Superman: Red Son {tmdbid=3)", "tmdbid", "3")]
-        [InlineData("Superman: Red Son (tvdbid-6}", "tvdbid", "6")]
+        [InlineData("Superman: Red Son {tmdbid=3}", "tmdbid", "3")]
+        [InlineData("Superman: Red Son (tvdbid-6)", "tvdbid", "6")]
         [InlineData("[tmdbid=618355]", "tmdbid", "618355")]
         [InlineData("{tmdbid=618355}", "tmdbid", "618355")]
         [InlineData("(tmdbid=618355)", "tmdbid", "618355")]
-- 
cgit v1.2.3