diff --git a/Emby.Naming/Video/VideoInfo.cs b/Emby.Naming/Video/VideoInfo.cs
index 8847ee9bc9..028b639122 100644
--- a/Emby.Naming/Video/VideoInfo.cs
+++ b/Emby.Naming/Video/VideoInfo.cs
@@ -17,8 +17,8 @@ namespace Emby.Naming.Video
         {
             Name = name;
 
-            Files = Array.Empty<VideoFileInfo>();
-            AlternateVersions = Array.Empty<VideoFileInfo>();
+            Files = [];
+            AlternateVersions = [];
         }
 
         /// <summary>
@@ -40,10 +40,10 @@ namespace Emby.Naming.Video
         public IReadOnlyList<VideoFileInfo> Files { get; set; }
 
         /// <summary>
-        /// Gets or sets the alternate versions.
+        /// Gets or sets the alternate versions. Each alternate may itself span multiple files.
         /// </summary>
         /// <value>The alternate versions.</value>
-        public IReadOnlyList<VideoFileInfo> AlternateVersions { get; set; }
+        public IReadOnlyList<VideoInfo> AlternateVersions { get; set; }
 
         /// <summary>
         /// Gets or sets the extra type.
diff --git a/Emby.Naming/Video/VideoListResolver.cs b/Emby.Naming/Video/VideoListResolver.cs
index a4bfb8d4a1..29330b132d 100644
--- a/Emby.Naming/Video/VideoListResolver.cs
+++ b/Emby.Naming/Video/VideoListResolver.cs
@@ -5,7 +5,8 @@ using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Emby.Naming.Common;
-using Jellyfin.Extensions;
+using Emby.Naming.TV;
+using Jellyfin.Data.Enums;
 using MediaBrowser.Model.IO;
 
 namespace Emby.Naming.Video
@@ -13,8 +14,23 @@ namespace Emby.Naming.Video
     /// <summary>
     /// Resolves alternative versions and extras from list of video files.
     /// </summary>
-    public static partial class VideoListResolver
+    public partial class VideoListResolver
     {
+        private static readonly StringComparer _numericOrdinalComparer = StringComparer.Create(CultureInfo.InvariantCulture, CompareOptions.NumericOrdering);
+
+        private readonly NamingOptions _namingOptions;
+        private readonly EpisodePathParser _episodePathParser;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VideoListResolver"/> class.
+        /// </summary>
+        /// <param name="namingOptions">The naming options.</param>
+        public VideoListResolver(NamingOptions namingOptions)
+        {
+            _namingOptions = namingOptions;
+            _episodePathParser = new EpisodePathParser(namingOptions);
+        }
+
         [GeneratedRegex("[0-9]{2}[0-9]+[ip]", RegexOptions.IgnoreCase)]
         private static partial Regex ResolutionRegex();
 
@@ -25,12 +41,12 @@ namespace Emby.Naming.Video
         /// Resolves alternative versions and extras from list of video files.
         /// </summary>
         /// <param name="videoInfos">List of related video files.</param>
-        /// <param name="namingOptions">The naming options.</param>
         /// <param name="supportMultiVersion">Indication we should consider multi-versions of content.</param>
         /// <param name="parseName">Whether to parse the name or use the filename.</param>
         /// <param name="libraryRoot">Top-level folder for the containing library.</param>
+        /// <param name="collectionType">The type of the containing collection, if known.</param>
         /// <returns>Returns enumerable of <see cref="VideoInfo"/> which groups files together when related.</returns>
-        public static IReadOnlyList<VideoInfo> Resolve(IReadOnlyList<VideoFileInfo> videoInfos, NamingOptions namingOptions, bool supportMultiVersion = true, bool parseName = true, string? libraryRoot = "")
+        public IReadOnlyList<VideoInfo> Resolve(IReadOnlyList<VideoFileInfo> videoInfos, bool supportMultiVersion = true, bool parseName = true, string? libraryRoot = "", CollectionType? collectionType = null)
         {
             // Filter out all extras, otherwise they could cause stacks to not be resolved
             // See the unit test TestStackedWithTrailer
@@ -38,7 +54,7 @@ namespace Emby.Naming.Video
                 .Where(i => i.ExtraType is null)
                 .Select(i => new FileSystemMetadata { FullName = i.Path, IsDirectory = i.IsDirectory });
 
-            var stackResult = StackResolver.Resolve(nonExtras, namingOptions).ToList();
+            var stackResult = StackResolver.Resolve(nonExtras, _namingOptions).ToList();
 
             var remainingFiles = new List<VideoFileInfo>();
             var standaloneMedia = new List<VideoFileInfo>();
@@ -67,7 +83,7 @@ namespace Emby.Naming.Video
             {
                 var info = new VideoInfo(stack.Name)
                 {
-                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, namingOptions, parseName, libraryRoot))
+                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, _namingOptions, parseName, libraryRoot))
                         .OfType<VideoFileInfo>()
                         .ToList()
                 };
@@ -86,7 +102,9 @@ namespace Emby.Naming.Video
 
             if (supportMultiVersion)
             {
-                list = GetVideosGroupedByVersion(list, namingOptions);
+                list = collectionType is CollectionType.tvshows
+                    ? GetEpisodesGroupedByVersion(list)
+                    : GetVideosGroupedByVersion(list);
             }
 
             // Whatever files are left, just add them
@@ -100,7 +118,7 @@ namespace Emby.Naming.Video
             return list;
         }
 
-        private static List<VideoInfo> GetVideosGroupedByVersion(List<VideoInfo> videos, NamingOptions namingOptions)
+        private List<VideoInfo> GetVideosGroupedByVersion(List<VideoInfo> videos)
         {
             if (videos.Count == 0)
             {
@@ -124,7 +142,7 @@ namespace Emby.Naming.Video
                     continue;
                 }
 
-                if (!IsEligibleForMultiVersion(folderName, video.Files[0].FileNameWithoutExtension, namingOptions))
+                if (!IsEligibleForMultiVersion(folderName, video.Files[0].FileNameWithoutExtension))
                 {
                     return videos;
                 }
@@ -135,45 +153,9 @@ namespace Emby.Naming.Video
                 }
             }
 
-            if (videos.Count > 1)
-            {
-                var groups = videos
-                    .Select(x => (filename: x.Files[0].FileNameWithoutExtension.ToString(), value: x))
-                    .Select(x => (x.filename, resolutionMatch: ResolutionRegex().Match(x.filename), x.value))
-                    .GroupBy(x => x.resolutionMatch.Success)
-                    .ToList();
+            var organized = OrganizeAlternateVersions(videos, primary, folderName.ToString());
 
-                videos.Clear();
-
-                StringComparer comparer = StringComparer.Create(CultureInfo.InvariantCulture, CompareOptions.NumericOrdering);
-                foreach (var group in groups)
-                {
-                    if (group.Key)
-                    {
-                        videos.InsertRange(0, group
-                            .OrderByDescending(x => x.resolutionMatch.Value, comparer)
-                            .ThenBy(x => x.filename, comparer)
-                            .Select(x => x.value));
-                    }
-                    else
-                    {
-                        videos.AddRange(group.OrderBy(x => x.filename, comparer).Select(x => x.value));
-                    }
-                }
-            }
-
-            primary ??= videos[0];
-            videos.Remove(primary);
-
-            var list = new List<VideoInfo>
-            {
-                primary
-            };
-
-            list[0].AlternateVersions = videos.Select(x => x.Files[0]).ToArray();
-            list[0].Name = folderName.ToString();
-
-            return list;
+            return [organized];
         }
 
         private static bool HaveSameYear(IReadOnlyList<VideoInfo> videos)
@@ -195,7 +177,7 @@ namespace Emby.Naming.Video
             return true;
         }
 
-        private static bool IsEligibleForMultiVersion(ReadOnlySpan<char> folderName, ReadOnlySpan<char> testFilename, NamingOptions namingOptions)
+        private bool IsEligibleForMultiVersion(ReadOnlySpan<char> folderName, ReadOnlySpan<char> testFilename)
         {
             if (!testFilename.StartsWith(folderName, StringComparison.OrdinalIgnoreCase))
             {
@@ -209,7 +191,7 @@ namespace Emby.Naming.Video
             }
 
             // There are no span overloads for regex unfortunately
-            if (CleanStringParser.TryClean(testFilename.ToString(), namingOptions.CleanStringRegexes, out var cleanName))
+            if (CleanStringParser.TryClean(testFilename.ToString(), _namingOptions.CleanStringRegexes, out var cleanName))
             {
                 testFilename = cleanName.AsSpan().Trim();
             }
@@ -221,5 +203,113 @@ namespace Emby.Naming.Video
                    || testFilename[0] == '.'
                    || CheckMultiVersionRegex().IsMatch(testFilename);
         }
+
+        private List<VideoInfo> GetEpisodesGroupedByVersion(List<VideoInfo> videos)
+        {
+            if (videos.Count < 2)
+            {
+                return videos;
+            }
+
+            var result = new List<VideoInfo>();
+            var groups = new Dictionary<string, List<VideoInfo>>(StringComparer.OrdinalIgnoreCase);
+
+            for (var i = 0; i < videos.Count; i++)
+            {
+                var video = videos[i];
+                var episodeResult = _episodePathParser.Parse(video.Files[0].Path, false);
+                string? key = null;
+                if (episodeResult.Success)
+                {
+                    if (episodeResult.IsByDate
+                        && episodeResult.Year.HasValue
+                        && episodeResult.Month.HasValue
+                        && episodeResult.Day.HasValue)
+                    {
+                        key = FormattableString.Invariant(
+                            $"D{episodeResult.Year.Value}{episodeResult.Month.Value:D2}{episodeResult.Day.Value:D2}");
+                    }
+                    else if (episodeResult.EpisodeNumber.HasValue)
+                    {
+                        key = FormattableString.Invariant(
+                            $"S{episodeResult.SeasonNumber ?? 0}E{episodeResult.EpisodeNumber.Value}");
+                    }
+                }
+
+                if (key is null)
+                {
+                    result.Add(video);
+                    continue;
+                }
+
+                if (!groups.TryGetValue(key, out var group))
+                {
+                    group = [];
+                    groups[key] = group;
+                }
+
+                group.Add(video);
+            }
+
+            foreach (var group in groups.Values)
+            {
+                if (group.Count == 1)
+                {
+                    result.Add(group[0]);
+                    continue;
+                }
+
+                result.Add(OrganizeAlternateVersions(group));
+            }
+
+            return result;
+        }
+
+        private static VideoInfo OrganizeAlternateVersions(
+            List<VideoInfo> videos,
+            VideoInfo? primaryOverride = null,
+            string? nameOverride = null)
+        {
+            if (videos.Count > 1)
+            {
+                var groups = videos
+                    .Select(x => (filename: x.Files[0].FileNameWithoutExtension.ToString(), value: x))
+                    .Select(x => (x.filename, resolutionMatch: ResolutionRegex().Match(x.filename), x.value))
+                    .GroupBy(x => x.resolutionMatch.Success)
+                    .ToList();
+
+                videos = [];
+
+                foreach (var group in groups)
+                {
+                    if (group.Key)
+                    {
+                        videos.InsertRange(0, group
+                            .OrderByDescending(x => x.resolutionMatch.Value, _numericOrdinalComparer)
+                            .ThenBy(x => x.filename, _numericOrdinalComparer)
+                            .Select(x => x.value));
+                    }
+                    else
+                    {
+                        videos.AddRange(group.OrderBy(x => x.filename, _numericOrdinalComparer).Select(x => x.value));
+                    }
+                }
+            }
+
+            // Prefer a stacked entry (more than one part) as primary
+            var primary = primaryOverride
+                ?? videos.FirstOrDefault(v => v.Files.Count > 1)
+                ?? videos[0];
+            videos.Remove(primary);
+
+            primary.AlternateVersions = videos;
+
+            if (nameOverride is not null)
+            {
+                primary.Name = nameOverride;
+            }
+
+            return primary;
+        }
     }
 }
diff --git a/Emby.Server.Implementations/ApplicationHost.cs b/Emby.Server.Implementations/ApplicationHost.cs
index b624a6d4f9..c81829688f 100644
--- a/Emby.Server.Implementations/ApplicationHost.cs
+++ b/Emby.Server.Implementations/ApplicationHost.cs
@@ -14,6 +14,7 @@ using System.Reflection;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 using Emby.Naming.Common;
+using Emby.Naming.Video;
 using Emby.Photos;
 using Emby.Server.Implementations.Chapters;
 using Emby.Server.Implementations.Collections;
@@ -540,6 +541,7 @@ namespace Emby.Server.Implementations
             serviceCollection.AddTransient(provider => new Lazy<IUserViewManager>(provider.GetRequiredService<IUserViewManager>));
             serviceCollection.AddSingleton<ILibraryManager, LibraryManager>();
             serviceCollection.AddSingleton<NamingOptions>();
+            serviceCollection.AddSingleton<VideoListResolver>();
 
             serviceCollection.AddSingleton<IMusicManager, MusicManager>();
 
diff --git a/Emby.Server.Implementations/Library/LibraryManager.cs b/Emby.Server.Implementations/Library/LibraryManager.cs
index 11f1496086..f2480679d9 100644
--- a/Emby.Server.Implementations/Library/LibraryManager.cs
+++ b/Emby.Server.Implementations/Library/LibraryManager.cs
@@ -13,6 +13,7 @@ using System.Threading.Tasks;
 using BitFaster.Caching.Lru;
 using Emby.Naming.Common;
 using Emby.Naming.TV;
+using Emby.Naming.Video;
 using Emby.Server.Implementations.Library.Resolvers;
 using Emby.Server.Implementations.Library.Validators;
 using Emby.Server.Implementations.Playlists;
@@ -787,6 +788,42 @@ namespace Emby.Server.Implementations.Library
             CollectionType? collectionType = null)
             => ResolvePath(fileInfo, directoryService ?? new DirectoryService(_fileSystem), null, parent, collectionType);
 
+        private void SetAdditionalPartsFromStack(Video altVideo, string path)
+        {
+            if (altVideo.AdditionalParts is { Length: > 0 })
+            {
+                return;
+            }
+
+            var directory = Path.GetDirectoryName(path);
+            if (string.IsNullOrEmpty(directory))
+            {
+                return;
+            }
+
+            IEnumerable<FileSystemMetadata> siblings;
+            try
+            {
+                siblings = _fileSystem.GetFiles(directory);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to enumerate siblings to detect stack for {Path}", path);
+                return;
+            }
+
+            var stacks = StackResolver.Resolve(siblings, _namingOptions);
+            foreach (var stack in stacks)
+            {
+                if (stack.Files.Count > 1
+                    && string.Equals(stack.Files[0], path, StringComparison.OrdinalIgnoreCase))
+                {
+                    altVideo.AdditionalParts = stack.Files.Skip(1).ToArray();
+                    return;
+                }
+            }
+        }
+
         /// <inheritdoc />
         public Video? ResolveAlternateVersion(string path, Type expectedVideoType, Folder? parent, CollectionType? collectionType)
         {
@@ -2307,6 +2344,10 @@ namespace Emby.Server.Implementations.Library
                             {
                                 altVideo.OwnerId = video.Id;
                                 altVideo.SetPrimaryVersionId(video.Id);
+                                // ResolveAlternateVersion only sees the alternate's primary file.
+                                // If the alternate is itself a stack (e.g. 1080p part1 + part2),
+                                // detect its parts from sibling files so its AdditionalParts persist.
+                                SetAdditionalPartsFromStack(altVideo, path);
                                 allItems.Add(altVideo);
                             }
                         }
@@ -2510,6 +2551,10 @@ namespace Emby.Server.Implementations.Library
                             {
                                 altVideo.OwnerId = video.Id;
                                 altVideo.SetPrimaryVersionId(video.Id);
+                                // ResolveAlternateVersion only sees the alternate's primary file.
+                                // If the alternate is itself a stack (e.g. 1080p part1 + part2),
+                                // detect its parts from sibling files so its AdditionalParts persist.
+                                SetAdditionalPartsFromStack(altVideo, path);
                                 allItems.Add(altVideo);
                             }
                         }
diff --git a/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs b/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
index 98e8f5350b..68b66ab7f5 100644
--- a/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
+++ b/Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs
@@ -28,15 +28,16 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
     public partial class MovieResolver : BaseVideoResolver<Video>, IMultiItemResolver
     {
         private readonly IImageProcessor _imageProcessor;
+        private readonly VideoListResolver _videoListResolver;
 
-        private static readonly CollectionType[] _validCollectionTypes = new[]
-        {
+        private static readonly CollectionType[] _validCollectionTypes =
+        [
             CollectionType.movies,
             CollectionType.homevideos,
             CollectionType.musicvideos,
             CollectionType.tvshows,
             CollectionType.photos
-        };
+        ];
 
         /// <summary>
         /// Initializes a new instance of the <see cref="MovieResolver"/> class.
@@ -45,10 +46,12 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
         /// <param name="logger">The logger.</param>
         /// <param name="namingOptions">The naming options.</param>
         /// <param name="directoryService">The directory service.</param>
-        public MovieResolver(IImageProcessor imageProcessor, ILogger<MovieResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService)
+        /// <param name="videoListResolver">The video list resolver.</param>
+        public MovieResolver(IImageProcessor imageProcessor, ILogger<MovieResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService, VideoListResolver videoListResolver)
             : base(logger, namingOptions, directoryService)
         {
             _imageProcessor = imageProcessor;
+            _videoListResolver = videoListResolver;
         }
 
         /// <summary>
@@ -228,7 +231,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
 
             if (collectionType == CollectionType.tvshows)
             {
-                return ResolveVideos<Episode>(parent, files, false, collectionType, true);
+                return ResolveVideos<Episode>(parent, files, true, collectionType, true);
             }
 
             return null;
@@ -274,7 +277,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                 .Where(f => f is not null)
                 .ToList();
 
-            var resolverResult = VideoListResolver.Resolve(videoInfos, NamingOptions, supportMultiEditions, parseName, parent.ContainingFolderPath);
+            var resolverResult = _videoListResolver.Resolve(videoInfos, supportMultiEditions, parseName, parent.ContainingFolderPath, collectionType);
 
             var result = new MultiItemResolverResult
             {
@@ -302,7 +305,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                     ProductionYear = video.Year,
                     Name = parseName ? video.Name : firstVideo.Name,
                     AdditionalParts = additionalParts,
-                    LocalAlternateVersions = video.AlternateVersions.Select(i => i.Path).ToArray()
+                    LocalAlternateVersions = video.AlternateVersions.Select(av => av.Files[0].Path).ToArray()
                 };
 
                 SetVideoType(videoItem, firstVideo);
@@ -331,9 +334,13 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
 
                 for (var j = 0; j < current.AlternateVersions.Count; j++)
                 {
-                    if (ContainsFile(current.AlternateVersions[j], file))
+                    var alternate = current.AlternateVersions[j];
+                    for (var k = 0; k < alternate.Files.Count; k++)
                     {
-                        return true;
+                        if (ContainsFile(alternate.Files[k], file))
+                        {
+                            return true;
+                        }
                     }
                 }
             }
diff --git a/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs b/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
index 2fb45600b1..b29c64f50d 100644
--- a/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
+++ b/tests/Jellyfin.Naming.Tests/Video/MultiVersionTests.cs
@@ -3,6 +3,8 @@ using System.Collections.Generic;
 using System.Linq;
 using Emby.Naming.Common;
 using Emby.Naming.Video;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Model.Entities;
 using Xunit;
 
 namespace Jellyfin.Naming.Tests.Video
@@ -10,6 +12,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 +30,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 +48,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 +65,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 +86,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 +108,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 +131,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 +150,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 +171,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,19 +192,18 @@ 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);
             Assert.Equal(6, result[0].AlternateVersions.Count);
-            Assert.Equal("/movies/Iron Man/Iron Man-720p.mkv", result[0].AlternateVersions[0].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man-3d.mkv", result[0].AlternateVersions[1].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man-3d-hsbs.mkv", result[0].AlternateVersions[2].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man-bluray.mkv", result[0].AlternateVersions[3].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man-test.mkv", result[0].AlternateVersions[4].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man[test].mkv", result[0].AlternateVersions[5].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man-720p.mkv", result[0].AlternateVersions[0].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man-3d.mkv", result[0].AlternateVersions[1].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man-3d-hsbs.mkv", result[0].AlternateVersions[2].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man-bluray.mkv", result[0].AlternateVersions[3].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man-test.mkv", result[0].AlternateVersions[4].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man[test].mkv", result[0].AlternateVersions[5].Files[0].Path);
         }
 
         [Fact]
@@ -221,19 +220,18 @@ 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);
             Assert.Equal(6, result[0].AlternateVersions.Count);
-            Assert.Equal("/movies/Iron Man/Iron Man - 720p.mkv", result[0].AlternateVersions[0].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man - 3d.mkv", result[0].AlternateVersions[1].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man - 3d-hsbs.mkv", result[0].AlternateVersions[2].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man - bluray.mkv", result[0].AlternateVersions[3].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man - test.mkv", result[0].AlternateVersions[4].Path);
-            Assert.Equal("/movies/Iron Man/Iron Man [test].mkv", result[0].AlternateVersions[5].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man - 720p.mkv", result[0].AlternateVersions[0].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man - 3d.mkv", result[0].AlternateVersions[1].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man - 3d-hsbs.mkv", result[0].AlternateVersions[2].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man - bluray.mkv", result[0].AlternateVersions[3].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man - test.mkv", result[0].AlternateVersions[4].Files[0].Path);
+            Assert.Equal("/movies/Iron Man/Iron Man [test].mkv", result[0].AlternateVersions[5].Files[0].Path);
         }
 
         [Fact]
@@ -245,9 +243,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,17 +263,16 @@ 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);
 
             // Verify 3D recognition is preserved on alternate versions
-            var hsbs = result[0].AlternateVersions.First(v => v.Path.Contains("3d-hsbs", StringComparison.Ordinal));
-            Assert.True(hsbs.Is3D);
-            Assert.Equal("hsbs", hsbs.Format3D);
+            var hsbs = result[0].AlternateVersions.First(v => v.Files[0].Path.Contains("3d-hsbs", StringComparison.Ordinal));
+            Assert.True(hsbs.Files[0].Is3D);
+            Assert.Equal("hsbs", hsbs.Files[0].Format3D);
         }
 
         [Fact]
@@ -293,9 +289,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 +305,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 +321,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,18 +341,17 @@ 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);
             Assert.Equal(5, result[0].AlternateVersions.Count);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 2160p.mkv", result[0].AlternateVersions[0].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p.mkv", result[0].AlternateVersions[1].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 720p.mkv", result[0].AlternateVersions[2].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - Directors Cut.mkv", result[0].AlternateVersions[3].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - Theatrical Release.mkv", result[0].AlternateVersions[4].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 2160p.mkv", result[0].AlternateVersions[0].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p.mkv", result[0].AlternateVersions[1].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 720p.mkv", result[0].AlternateVersions[2].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - Directors Cut.mkv", result[0].AlternateVersions[3].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - Theatrical Release.mkv", result[0].AlternateVersions[4].Files[0].Path);
         }
 
         [Fact]
@@ -381,24 +373,23 @@ 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);
             Assert.Equal(11, result[0].AlternateVersions.Count);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 2160p.mkv", result[0].AlternateVersions[0].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 2160p Remux.mkv", result[0].AlternateVersions[1].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p.mkv", result[0].AlternateVersions[2].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p Directors Cut.mkv", result[0].AlternateVersions[3].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p High Bitrate.mkv", result[0].AlternateVersions[4].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p Remux.mkv", result[0].AlternateVersions[5].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p Theatrical Release.mkv", result[0].AlternateVersions[6].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 720p.mkv", result[0].AlternateVersions[7].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 720p Directors Cut.mkv", result[0].AlternateVersions[8].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - Directors Cut.mkv", result[0].AlternateVersions[9].Path);
-            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - Theatrical Release.mkv", result[0].AlternateVersions[10].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 2160p.mkv", result[0].AlternateVersions[0].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 2160p Remux.mkv", result[0].AlternateVersions[1].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p.mkv", result[0].AlternateVersions[2].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p Directors Cut.mkv", result[0].AlternateVersions[3].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p High Bitrate.mkv", result[0].AlternateVersions[4].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p Remux.mkv", result[0].AlternateVersions[5].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 1080p Theatrical Release.mkv", result[0].AlternateVersions[6].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 720p.mkv", result[0].AlternateVersions[7].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - 720p Directors Cut.mkv", result[0].AlternateVersions[8].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - Directors Cut.mkv", result[0].AlternateVersions[9].Files[0].Path);
+            Assert.Equal("/movies/X-Men Apocalypse (2016)/X-Men Apocalypse (2016) - Theatrical Release.mkv", result[0].AlternateVersions[10].Files[0].Path);
         }
 
         [Fact]
@@ -410,9 +401,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 +417,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 +426,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 +440,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,12 +456,679 @@ 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);
         }
+
+        // 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].Files[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].Files[0].Path, StringComparison.Ordinal);
+            Assert.Contains("720p", result[0].AlternateVersions[1].Files[0].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].Files[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].Files[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].Files[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].Files[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].Files[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].Files[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].Files[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 TestMultiVersionEpisodePartStackAlongsideSingleFileResolutions()
+        {
+            // A part-stacked episode (3 parts, no resolution suffix) alongside single-file 720p and 1080p versions.
+            // The multi-part stack is preferred as primary.
+            var files = new[]
+            {
+                "/TV/Show/Season 1/S01E01 - 720p.mkv",
+                "/TV/Show/Season 1/S01E01 - 1080p.mkv",
+                "/TV/Show/Season 1/S01E01 - Part 1.mkv",
+                "/TV/Show/Season 1/S01E01 - Part 2.mkv",
+                "/TV/Show/Season 1/S01E01 - Part 3.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].Files.Count);
+            Assert.All(result[0].Files, f => Assert.Contains("Part", f.Path, StringComparison.Ordinal));
+            Assert.Equal(2, result[0].AlternateVersions.Count);
+            Assert.Contains(result[0].AlternateVersions, f => f.Files[0].Path.Contains("1080p", StringComparison.Ordinal));
+            Assert.Contains(result[0].AlternateVersions, f => f.Files[0].Path.Contains("720p", StringComparison.Ordinal));
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodeTwoPartStacks()
+        {
+            // Two part-suffixed stacks of the same episode at different resolutions.
+            // The 1080p stack is primary, the 720p stack is preserved as a multi-file alternate.
+            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 - part1.mkv",
+                "/TV/Show/Season 1/Show - S01E01 - 720p - part2.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.Contains("1080p", result[0].Files[0].Path, StringComparison.Ordinal);
+
+            Assert.Single(result[0].AlternateVersions);
+            var alt = result[0].AlternateVersions[0];
+            Assert.Equal(2, alt.Files.Count);
+            Assert.All(alt.Files, f => Assert.Contains("720p", f.Path, StringComparison.Ordinal));
+        }
+
+        [Fact]
+        public void TestMultiVersionEpisodePartStackWithTrailer()
+        {
+            // A part-stacked multi-version episode alongside a trailer must not pull the trailer into the version group
+            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",
+                "/TV/Show/Season 1/Show - S01E01-trailer.mp4"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList(),
+                collectionType: CollectionType.tvshows).ToList();
+
+            Assert.Equal(2, result.Count);
+
+            var episode = result.FirstOrDefault(r => r.ExtraType is null);
+            Assert.NotNull(episode);
+            Assert.Equal(2, episode!.Files.Count);
+            Assert.Single(episode.AlternateVersions);
+            Assert.Contains("720p", episode.AlternateVersions[0].Files[0].Path, StringComparison.Ordinal);
+
+            var trailer = result.FirstOrDefault(r => r.ExtraType is not null);
+            Assert.NotNull(trailer);
+            Assert.Equal(ExtraType.Trailer, trailer!.ExtraType);
+        }
+
+        [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 TestMovieMultiVersionWithStackedAlternate()
+        {
+            // Movie folder where the folder-named file is the primary (single file via primaryOverride)
+            // and an alternate version is itself a stack. The stacked alternate must keep all its files.
+            var files = new[]
+            {
+                "/movies/Inception (2010)/Inception (2010).mkv",
+                "/movies/Inception (2010)/Inception (2010) - 4k part1.mkv",
+                "/movies/Inception (2010)/Inception (2010) - 4k part2.mkv"
+            };
+
+            var result = _videoListResolver.Resolve(
+                files.Select(i => VideoResolver.Resolve(i, false, _namingOptions)).OfType<VideoFileInfo>().ToList()).ToList();
+
+            Assert.Single(result);
+            Assert.Single(result[0].Files);
+            Assert.Equal("/movies/Inception (2010)/Inception (2010).mkv", result[0].Files[0].Path);
+
+            Assert.Single(result[0].AlternateVersions);
+            var stackedAlternate = result[0].AlternateVersions[0];
+            Assert.Equal(2, stackedAlternate.Files.Count);
+            Assert.All(stackedAlternate.Files, f => Assert.Contains("4k part", f.Path, StringComparison.Ordinal));
+        }
+
+        [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(),
+                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);
+    }
 }