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>
---
 tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'tests/Jellyfin.Server.Implementations.Tests')

diff --git a/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Item/OrderMapperTests.cs
index caf2b06b73..8ac3e5e317 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/Jellyfin.Server.Implementations.Tests')

diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 84168291a8..57d874e59f 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 0000000000..eadabf6776
--- /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 0000000000..8fbccd8019
--- /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/Jellyfin.Server.Implementations.Tests')

diff --git a/Emby.Server.Implementations/Library/PathExtensions.cs b/Emby.Server.Implementations/Library/PathExtensions.cs
index 21e7079d88..fc63251ad0 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 940e3c2b12..74cd303bab 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/Jellyfin.Server.Implementations.Tests')

diff --git a/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs b/Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs
index 473ff8e1d7..ef5d24c70f 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 d677c9f091..a7bbef7ed4 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/Jellyfin.Server.Implementations.Tests')

diff --git a/Emby.Server.Implementations/Localization/LocalizationManager.cs b/Emby.Server.Implementations/Localization/LocalizationManager.cs
index b4c65ad85f..d99ad4665e 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 6d6bba4fc4..e60522bf78 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 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/Jellyfin.Server.Implementations.Tests')

diff --git a/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs b/Jellyfin.Server.Implementations/Item/BaseItemRepository.cs
index 85ab00a2bf..b7f1c23e0c 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 d221d18531..4b1e53a355 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 0000000000..c450cbb0e1
--- /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/Jellyfin.Server.Implementations.Tests')

diff --git a/CONTRIBUTORS.md b/CONTRIBUTORS.md
index 0fd509f842..171509382d 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 5380c45d84..0381c4d355 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 0000000000..052bdf740e
--- /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 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/Jellyfin.Server.Implementations.Tests')

diff --git a/Emby.Server.Implementations/IO/LibraryMonitor.cs b/Emby.Server.Implementations/IO/LibraryMonitor.cs
index d87ad729ee..7cff2a25b6 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 fe3a1ce611..5fac2f6b0a 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 07061cfc77..4cb6cb9607 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/Jellyfin.Server.Implementations.Tests')

diff --git a/Emby.Server.Implementations/Library/IgnorePatterns.cs b/Emby.Server.Implementations/Library/IgnorePatterns.cs
index 5fac2f6b0a..59ccb9e2c7 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 4cb6cb9607..07061cfc77 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/Jellyfin.Server.Implementations.Tests')

diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/PathExtensionsTests.cs
index 74cd303bab..650d67b195 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