Implement multiple versions for episodes.

3 files changed, 714 insertions, 124 deletions

diff --git a/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs b/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
index 2fb45600b1..70daa506fd 100644
--- a/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
@@ -3,6 +3,7 @@ using System.Collections.Generic;
 using System.Linq;
 using Emby.Naming.Common;
 using Emby.Naming.Video;
+using Jellyfin.Data.Enums;
 using Xunit;
 
 namespace Jellyfin.Naming.Tests.Video
@@ -10,6 +11,12 @@ namespace Jellyfin.Naming.Tests.Video
     public class MultiVersionTests
     {
         private readonly NamingOptions _namingOptions = new NamingOptions();
+        private readonly VideoListResolver _videoListResolver;
+
+        public MultiVersionTests()
+        {
+            _videoListResolver = new VideoListResolver(_namingOptions);
+        }
 
         [Fact]
         public void TestMultiEdition1()
@@ -22,9 +29,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/X-Men Days of Future Past/X-Men Days of Future Past [hsbs].mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result, v => v.ExtraType is null);
             Assert.Single(result, v => v.ExtraType is not null);
@@ -41,9 +47,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/X-Men Days of Future Past/X-Men Days of Future Past [banana].mp4"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result, v => v.ExtraType is null);
             Assert.Single(result, v => v.ExtraType is not null);
@@ -59,9 +64,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/The Phantom of the Opera (1925)/The Phantom of the Opera (1925) - 1929 version.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Single(result[0].AlternateVersions);
@@ -81,9 +85,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/M/Movie 7.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(7, result.Count);
             Assert.Empty(result[0].AlternateVersions);
@@ -104,9 +107,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Movie/Movie-8.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Equal(7, result[0].AlternateVersions.Count);
@@ -128,9 +130,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Mo/Movie 9.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(9, result.Count);
             Assert.Empty(result[0].AlternateVersions);
@@ -148,9 +149,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Movie/Movie 5.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(5, result.Count);
             Assert.Empty(result[0].AlternateVersions);
@@ -170,9 +170,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Iron Man/Iron Man (2011).mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(5, result.Count);
             Assert.Empty(result[0].AlternateVersions);
@@ -192,9 +191,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Iron Man/Iron Man[test].mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Equal("/movies/Iron Man/Iron Man.mkv", result[0].Files[0].Path);
@@ -221,9 +219,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Iron Man/Iron Man [test].mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Equal("/movies/Iron Man/Iron Man.mkv", result[0].Files[0].Path);
@@ -245,9 +242,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Iron Man/Iron Man - C (2007).mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -266,9 +262,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Iron Man/Iron Man_3d.hsbs.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Equal(6, result[0].AlternateVersions.Count);
@@ -293,9 +288,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Iron Man/Iron Man (2011).mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(5, result.Count);
             Assert.Empty(result[0].AlternateVersions);
@@ -310,9 +304,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Blade Runner (1982)/Blade Runner (1982) [EE by ADM] [480p HEVC AAC,AAC,AAC].mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Single(result[0].AlternateVersions);
@@ -327,9 +320,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) [2160p] Blu-ray.x265.AAC.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Single(result[0].AlternateVersions);
@@ -348,9 +340,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016).mkv",
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016).mkv", result[0].Files[0].Path);
@@ -381,9 +372,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016).mkv",
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016).mkv", result[0].Files[0].Path);
@@ -410,9 +400,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/John Wick - Kapitel 3 (2019) [imdbid=tt6146586]/John Wick - Kapitel 3 (2019) [imdbid=tt6146586] - Version 2.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Single(result[0].AlternateVersions);
@@ -427,9 +416,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/John Wick - Chapter 3 (2019)/John Wick - Chapter 3 (2019) [Version 2.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -437,7 +425,7 @@ namespace Jellyfin.Naming.Tests.Video
         [Fact]
         public void TestEmptyList()
         {
-            var result = VideoListResolver.Resolve(new List<VideoFileInfo>(), _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(new List<VideoFileInfo>()).ToList();
 
             Assert.Empty(result);
         }
@@ -451,9 +439,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Movie (2020)/Movie (2020)_1080p.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
             Assert.Single(result[0].AlternateVersions);
@@ -468,11 +455,571 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Movie (2020)/Movie (2020).1080p.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
+
+            Assert.Single(result);
+            Assert.Single(result[0].AlternateVersions);
+        }
+
+        // Episode multi-version tests
+
+        [Fact]
+        public void TestMultiVersionEpisodeInOwnFolder()
+        {
+            // Two versions of S01E01 in their own subfolder should merge
+            var files = new[]
+            {
+                "/TV/Dexter/Dexter - S01E01/Dexter - S01E01 - 1080p.mkv",
+                "/TV/Dexter/Dexter - S01E01/Dexter - S01E01 - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Single(result[0].AlternateVersions);
+            // 1080p should be primary (higher resolution)
+            Assert.Contains("1080p", result[0].Files[0].Path, StringComparison.Ordinal);
+            Assert.Contains("720p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeMixedSeasonFolder()
+        {
+            // Multiple episodes in season folder, some with versions
+            var files = new[]
+            {
+                "/TV/Dexter/Season 1/Dexter - S01E01 - 1080p.mkv",
+                "/TV/Dexter/Season 1/Dexter - S01E01 - 720p.mkv",
+                "/TV/Dexter/Season 1/Dexter - S01E02.mkv",
+                "/TV/Dexter/Season 1/Dexter - S01E03 - 1080p.mkv",
+                "/TV/Dexter/Season 1/Dexter - S01E03 - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Equal(3, result.Count);
+
+            // S01E01 - should have one alternate version
+            var e01 = result.FirstOrDefault(r => r.Files[0].Path.Contains("S01E01", StringComparison.Ordinal));
+            Assert.NotNull(e01);
+            Assert.Single(e01!.AlternateVersions);
+            Assert.Contains("1080p", e01.Files[0].Path, StringComparison.Ordinal);
+
+            // S01E02 - standalone, no alternates
+            var e02 = result.FirstOrDefault(r => r.Files[0].Path.Contains("S01E02", StringComparison.Ordinal));
+            Assert.NotNull(e02);
+            Assert.Empty(e02!.AlternateVersions);
+
+            // S01E03 - should have one alternate version
+            var e03 = result.FirstOrDefault(r => r.Files[0].Path.Contains("S01E03", StringComparison.Ordinal));
+            Assert.NotNull(e03);
+            Assert.Single(e03!.AlternateVersions);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeDontCollapse()
+        {
+            // Different episodes should NOT collapse into versions
+            var files = new[]
+            {
+                "/TV/Dexter/Season 1/Dexter - S01E01.mkv",
+                "/TV/Dexter/Season 1/Dexter - S01E02.mkv",
+                "/TV/Dexter/Season 1/Dexter - S01E03.mkv",
+                "/TV/Dexter/Season 1/Dexter - S01E04.mkv",
+                "/TV/Dexter/Season 1/Dexter - S01E05.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Equal(5, result.Count);
+            Assert.All(result, r => Assert.Empty(r.AlternateVersions));
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithVersionSuffix()
+        {
+            // Episodes with named versions (like Aired/Uncensored)
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - Aired.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Uncensored.mkv",
+                "/TV/Show/Season 1/Show - S01E02 - Aired.mkv",
+                "/TV/Show/Season 1/Show - S01E02 - Uncensored.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Equal(2, result.Count);
+            Assert.All(result, r => Assert.Single(r.AlternateVersions));
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeFourVersions()
+        {
+            // Four versions of the same episode
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - VersionA.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - VersionB.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - VersionC.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - VersionD.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(3, result[0].AlternateVersions.Count);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithResolutions()
+        {
+            // Resolution sorting should work for episodes too
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - 720p.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 2160p.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 1080p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(2, result[0].AlternateVersions.Count);
+            // Primary should be 2160p (highest resolution)
+            Assert.Contains("2160p", result[0].Files[0].Path, StringComparison.Ordinal);
+            // Next should be 1080p, then 720p
+            Assert.Contains("1080p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+            Assert.Contains("720p", result[0].AlternateVersions[1].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeDifferentSeasons()
+        {
+            // Same episode number but different seasons should NOT group
+            var files = new[]
+            {
+                "/TV/Show/Show - S01E01.mkv",
+                "/TV/Show/Show - S02E01.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Equal(2, result.Count);
+            Assert.All(result, r => Assert.Empty(r.AlternateVersions));
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeDisabledByDefault()
+        {
+            // Without collectionType: CollectionType.tvshows, episodes should NOT group
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - 1080p.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
+
+            // Without the tvshows collection type, these fall through the movie path
+            // (folder-name eligibility fails) and are treated as separate items.
+            Assert.Equal(2, result.Count);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeSameNumberDifferentTitle()
+        {
+            // Two files parse to the same S01E01 but carry distinct episode titles.
+            // Current behavior: they are grouped as alternate versions because
+            // grouping keys only on season + episode number, not on episode title.
+            // This documents the trade-off: users with mis-numbered episodes will
+            // see one of the files collapsed into AlternateVersions of the other.
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - Pilot.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Completely Different Title.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Single(result[0].AlternateVersions);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithTitle()
+        {
+            // Episodes with an episode title AND a version suffix should group
+            var files = new[]
+            {
+                "/TV/Show/Show - S01E01/Show - S01E01 - Episode Title - 1080p.mkv",
+                "/TV/Show/Show - S01E01/Show - S01E01 - Episode Title - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Single(result[0].AlternateVersions);
+            Assert.Contains("1080p", result[0].Files[0].Path, StringComparison.Ordinal);
+            Assert.Contains("720p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithTitleMixedFolder()
+        {
+            // Multiple different episodes with titles and resolution variants in a season folder
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - 1080p.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - 720p.mkv",
+                "/TV/Show/Season 1/Show - S01E02 - Second Episode - 1080p.mkv",
+                "/TV/Show/Season 1/Show - S01E02 - Second Episode - 720p.mkv",
+                "/TV/Show/Season 1/Show - S01E03 - Third Episode.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Equal(3, result.Count);
+
+            var e01 = result.FirstOrDefault(r => r.Files[0].Path.Contains("S01E01", StringComparison.Ordinal));
+            Assert.NotNull(e01);
+            Assert.Single(e01!.AlternateVersions);
+
+            var e02 = result.FirstOrDefault(r => r.Files[0].Path.Contains("S01E02", StringComparison.Ordinal));
+            Assert.NotNull(e02);
+            Assert.Single(e02!.AlternateVersions);
+
+            var e03 = result.FirstOrDefault(r => r.Files[0].Path.Contains("S01E03", StringComparison.Ordinal));
+            Assert.NotNull(e03);
+            Assert.Empty(e03!.AlternateVersions);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeInSeasonSubfolder()
+        {
+            // Two versions of S01E01 in their own subfolder under a season folder
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01/Show - S01E01 - 1080p.mkv",
+                "/TV/Show/Season 1/Show - S01E01/Show - S01E01 - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Single(result[0].AlternateVersions);
+            Assert.Contains("1080p", result[0].Files[0].Path, StringComparison.Ordinal);
+            Assert.Contains("720p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithTitleAndVersionSuffix()
+        {
+            // Episodes with episode title AND a named version suffix
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - Aired.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - Uncensored.mkv",
+                "/TV/Show/Season 1/Show - S01E02 - The Getaway - Aired.mkv",
+                "/TV/Show/Season 1/Show - S01E02 - The Getaway - Uncensored.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Equal(2, result.Count);
+            Assert.All(result, r => Assert.Single(r.AlternateVersions));
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithAdditionalPartsCd()
+        {
+            // Stacked episode (cd1/cd2) with higher resolution alongside a single-file lower-res version
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - 1080p cd1.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 1080p cd2.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(2, result[0].Files.Count);
+            Assert.Single(result[0].AlternateVersions);
+            Assert.Contains("720p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithAdditionalPartsDashPart()
+        {
+            // Stacked episode using "- part1" / "- part2" separator
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - 1080p - part1.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 1080p - part2.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(2, result[0].Files.Count);
+            Assert.Single(result[0].AlternateVersions);
+            Assert.Contains("720p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithAdditionalPartsPt()
+        {
+            // Stacked episode using "pt1" / "pt2" short form
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - 1080p.pt1.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 1080p.pt2.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(2, result[0].Files.Count);
+            Assert.Single(result[0].AlternateVersions);
+            Assert.Contains("720p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithAdditionalPartsAndTitle()
+        {
+            // Stacked episode with episode title in filename
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - 1080p part1.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - 1080p part2.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            // Primary should be the stacked 1080p version with 2 files
+            Assert.Equal(2, result[0].Files.Count);
+            Assert.Single(result[0].AlternateVersions);
+            Assert.Contains("720p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithAdditionalPartsAndTitleDashSeparator()
+        {
+            // Stacked episode with episode title using "- part1" separator
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - 1080p - part1.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - 1080p - part2.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Pilot - 720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            // Primary should be the stacked 1080p version with 2 files
+            Assert.Equal(2, result[0].Files.Count);
+            Assert.Single(result[0].AlternateVersions);
+            Assert.Contains("720p", result[0].AlternateVersions[0].Path, StringComparison.Ordinal);
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeWithAdditionalPartsAndMultipleEpisodes()
+        {
+            // Stacked episode alongside single-file version, plus a different episode
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - 1080p cd1.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 1080p cd2.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 720p.mkv",
+                "/TV/Show/Season 1/Show - S01E02 - Other.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Equal(2, result.Count);
+
+            // S01E01: stacked (cd1+cd2) primary with 720p alternate
+            var e01 = result.FirstOrDefault(r => r.Files[0].Path.Contains("S01E01", StringComparison.Ordinal));
+            Assert.NotNull(e01);
+            Assert.Equal(2, e01!.Files.Count);
+            Assert.Single(e01.AlternateVersions);
+
+            // S01E02: standalone
+            var e02 = result.FirstOrDefault(r => r.Files[0].Path.Contains("S01E02", StringComparison.Ordinal));
+            Assert.NotNull(e02);
+            Assert.Empty(e02!.AlternateVersions);
+        }
+
+        [Fact]
+        public void TestMovieStackingWithPartNaming()
+        {
+            // Movie stacking with "part1"/"part2" naming
+            var files = new[]
+            {
+                "/movies/Movie/Movie part1.mkv",
+                "/movies/Movie/Movie part2.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(2, result[0].Files.Count);
+        }
+
+        [Fact]
+        public void TestMovieStackingWithDashPartNaming()
+        {
+            // Movie stacking with "- part1" / "- part2" dash separator
+            var files = new[]
+            {
+                "/movies/Movie/Movie - part1.mkv",
+                "/movies/Movie/Movie - part2.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(2, result[0].Files.Count);
+        }
+
+        [Fact]
+        public void TestMovieStackingWithPtNaming()
+        {
+            // Movie stacking with "pt1"/"pt2" short form
+            var files = new[]
+            {
+                "/movies/Movie/Movie.pt1.mkv",
+                "/movies/Movie/Movie.pt2.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(2, result[0].Files.Count);
+        }
+
+        [Fact]
+        public void TestMovieStackingWithHyphenNoSpaces()
+        {
+            // Movie stacking with hyphen directly adjacent to "part" (no spaces)
+            var files = new[]
+            {
+                "/movies/Movie/Movie-part1.mkv",
+                "/movies/Movie/Movie-part2.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
+
+            Assert.Single(result);
+            Assert.Equal(2, result[0].Files.Count);
+        }
+
+        [Fact]
+        public void TestMovieStackingWithHyphenNoSpacesAndVersion()
+        {
+            // Movie stacking with hyphen-no-space separators plus a version alternate
+            var files = new[]
+            {
+                "/movies/Movie/Movie-1080p-part1.mkv",
+                "/movies/Movie/Movie-1080p-part2.mkv",
+                "/movies/Movie/Movie-720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
+
+            Assert.Single(result);
+            // Stacked 1080p (2 files) should be primary, 720p is alternate
+            Assert.Equal(2, result[0].Files.Count);
+            Assert.Single(result[0].AlternateVersions);
+        }
+
+        [Fact]
+        public void TestEpisodeStackingWithHyphenNoSpaces()
+        {
+            // Episode stacking with hyphen-no-space separators plus version alternate
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01-1080p-cd1.mkv",
+                "/TV/Show/Season 1/Show - S01E01-1080p-cd2.mkv",
+                "/TV/Show/Season 1/Show - S01E01-720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Single(result);
+            // Stacked 1080p (2 files) should be primary, 720p is alternate
+            Assert.Equal(2, result[0].Files.Count);
+            Assert.Single(result[0].AlternateVersions);
+        }
+
+        [Fact]
+        public void TestEpisodeStackingWithHyphenNoSpacesAndTitle()
+        {
+            // Episode stacking with title and hyphen-no-space separators
+            var files = new[]
+            {
+                "/TV/Show/Season 1/Show - S01E01 - Pilot-1080p-part1.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Pilot-1080p-part2.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - Pilot-720p.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
                 files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+                collectionType: CollectionType.tvshows).ToList();
 
             Assert.Single(result);
+            // Stacked 1080p (2 files) should be primary, 720p is alternate
+            Assert.Equal(2, result[0].Files.Count);
             Assert.Single(result[0].AlternateVersions);
         }
     }
diff --git a/tests/Jellyfin.Naming.Tests/Video/VideoListResolverTests.cs b/tests/Jellyfin.Naming.Tests/Video/VideoListResolverTests.cs
index d3164ba9c9..53f16b92d6 100644
--- a/tests/Jellyfin.Naming.Tests/Video/VideoListResolverTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/VideoListResolverTests.cs
@@ -10,6 +10,12 @@ namespace Jellyfin.Naming.Tests.Video
     public class VideoListResolverTests
     {
         private readonly NamingOptions _namingOptions = new NamingOptions();
+        private readonly VideoListResolver _videoListResolver;
+
+        public VideoListResolverTests()
+        {
+            _videoListResolver = new VideoListResolver(_namingOptions);
+        }
 
         [Fact]
         public void TestStackAndExtras()
@@ -40,9 +46,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "WillyWonka-trailer.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(11, result.Count);
             var batman = result.FirstOrDefault(x => string.Equals(x.Name, "Batman", StringComparison.Ordinal));
@@ -74,9 +79,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "300.nfo"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
         }
@@ -90,9 +94,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "300 - trailer.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -108,9 +111,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "X-Men Days of Future Past-trailer.mp4"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -127,9 +129,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "X-Men Days of Future Past-trailer2.mp4"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(3, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -147,9 +148,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "Looper.2012.bluray.720p.x264.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(3, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -166,9 +166,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/movies/Looper (2012)/Looper.bluray.720p.x264.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -188,9 +187,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "My video 5.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(5, result.Count);
         }
@@ -204,9 +202,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "M:/Movies (DVD)/Movies (Musical)/Sound of Music (1965)/Sound of Music Disc 2"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, true, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, true, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
         }
@@ -221,9 +218,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "My movie #2.mp4"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, true, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, true, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -239,9 +235,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "No (2012)-trailer.mp4"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(3, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -260,9 +255,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/Movies/trailer.mp4"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(4, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -282,9 +276,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/MCFAMILY-PC/Private3$/Heterosexual/Breast In Class 2 Counterfeit Racks (2011)/Breast In Class 2 Disc 2 cd2.avi"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -297,9 +290,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/nas-markrobbo78/Videos/INDEX HTPC/Movies/Watched/3 - ACTION/Argo (2012)/movie.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
         }
@@ -312,9 +304,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "The Colony.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Single(result);
         }
@@ -328,9 +319,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "Four Sisters and a Wedding - B.avi"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             // The result should contain two individual movies
             // Version grouping should not work here, because the files are not in a directory with the name 'Four Sisters and a Wedding'
@@ -346,9 +336,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "Four Rooms - A.mp4"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
         }
@@ -362,9 +351,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/Server/Despicable Me/trailer.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -380,9 +368,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/Server/Despicable Me/trailers/some title.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
@@ -398,9 +385,8 @@ namespace Jellyfin.Naming.Tests.Video
                 "/Movies/Despicable Me/trailers/trailer.mkv"
             };
 
-            var result = VideoListResolver.Resolve(
-                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
-                _namingOptions).ToList();
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
 
             Assert.Equal(2, result.Count);
             Assert.False(result[0].ExtraType.HasValue);
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Library/MovieResolverTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Library/MovieResolverTests.cs
index aed584355c..e1346a8436 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Library/MovieResolverTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Library/MovieResolverTests.cs
@@ -1,7 +1,13 @@
+using System.Collections.Generic;
 using Emby.Naming.Common;
+using Emby.Naming.Video;
 using Emby.Server.Implementations.Library.Resolvers.Movies;
+using Jellyfin.Data.Enums;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Drawing;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.IO;
@@ -14,11 +20,12 @@ namespace Jellyfin.Server.Implementations.Tests.Library;
 public class MovieResolverTests
 {
     private static readonly NamingOptions _namingOptions = new();
+    private static readonly VideoListResolver _videoListResolver = new(_namingOptions);
 
     [Fact]
     public void Resolve_GivenLocalAlternateVersion_ResolvesToVideo()
     {
-        var movieResolver = new MovieResolver(Mock.Of<IImageProcessor>(), Mock.Of<ILogger<MovieResolver>>(), _namingOptions, Mock.Of<IDirectoryService>());
+        var movieResolver = new MovieResolver(Mock.Of<IImageProcessor>(), Mock.Of<ILogger<MovieResolver>>(), _namingOptions, Mock.Of<IDirectoryService>(), _videoListResolver);
         var itemResolveArgs = new ItemResolveArgs(
             Mock.Of<IServerApplicationPaths>(),
             null)
@@ -32,4 +39,54 @@ public class MovieResolverTests
 
         Assert.NotNull(movieResolver.Resolve(itemResolveArgs));
     }
+
+    [Fact]
+    public void ResolveMultiple_GivenTvShowsCollection_CreatesEpisodeItems()
+    {
+        // For a tvshows collection, the multi-version grouping must still produce
+        // Episode BaseItems (not generic Video) so downstream metadata fetching
+        // and series-aware logic apply.
+        var movieResolver = new MovieResolver(Mock.Of<IImageProcessor>(), Mock.Of<ILogger<MovieResolver>>(), _namingOptions, Mock.Of<IDirectoryService>(), _videoListResolver);
+
+        var parent = new Folder { Path = "/TV/Show/Season 1" };
+        var files = new List<FileSystemMetadata>
+        {
+            new() { FullName = "/TV/Show/Season 1/Show - S01E01 - 1080p.mkv", Name = "Show - S01E01 - 1080p.mkv", IsDirectory = false },
+            new() { FullName = "/TV/Show/Season 1/Show - S01E01 - 720p.mkv", Name = "Show - S01E01 - 720p.mkv", IsDirectory = false },
+            new() { FullName = "/TV/Show/Season 1/Show - S01E02.mkv", Name = "Show - S01E02.mkv", IsDirectory = false }
+        };
+
+        var result = movieResolver.ResolveMultiple(parent, files, CollectionType.tvshows, Mock.Of<IDirectoryService>());
+
+        Assert.NotNull(result);
+        Assert.Equal(2, result.Items.Count);
+        Assert.All(result.Items, item => Assert.IsType<Episode>(item));
+
+        // The S01E01 item should have one alternate version
+        var s01e01 = result.Items.Find(i => i.Path.Contains("S01E01", System.StringComparison.Ordinal));
+        Assert.NotNull(s01e01);
+        Assert.Single(((Video)s01e01).LocalAlternateVersions);
+    }
+
+    [Fact]
+    public void ResolveMultiple_GivenMoviesCollection_CreatesMovieItems()
+    {
+        // For a movies collection, the multi-version grouping must produce Movie
+        // BaseItems (not generic Video) so downstream movie-specific logic applies.
+        var movieResolver = new MovieResolver(Mock.Of<IImageProcessor>(), Mock.Of<ILogger<MovieResolver>>(), _namingOptions, Mock.Of<IDirectoryService>(), _videoListResolver);
+
+        var parent = new Folder { Path = "/movies/Inception (2010)" };
+        var files = new List<FileSystemMetadata>
+        {
+            new() { FullName = "/movies/Inception (2010)/Inception (2010) - 1080p.mkv", Name = "Inception (2010) - 1080p.mkv", IsDirectory = false },
+            new() { FullName = "/movies/Inception (2010)/Inception (2010) - 720p.mkv", Name = "Inception (2010) - 720p.mkv", IsDirectory = false }
+        };
+
+        var result = movieResolver.ResolveMultiple(parent, files, CollectionType.movies, Mock.Of<IDirectoryService>());
+
+        Assert.NotNull(result);
+        Assert.Single(result.Items);
+        Assert.All(result.Items, item => Assert.IsType<Movie>(item));
+        Assert.Single(((Video)result.Items[0]).LocalAlternateVersions);
+    }
 }