2 files changed, 189 insertions, 1 deletions
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
index 6b6240e116..6a3dcab57a 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceImageInheritanceTests.cs
@@ -9,11 +9,13 @@ using MediaBrowser.Controller.Drawing;
 using MediaBrowser.Controller.Dto;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Entities.Movies;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Controller.Trickplay;
 using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Querying;
 using Moq;
 using Xunit;
 
@@ -155,6 +157,133 @@ public class DtoServiceImageInheritanceTests
         libraryManager.Verify(x => x.GetArtist(It.IsAny<string>(), It.IsAny<DtoOptions>()), Times.Never);
     }
 
+    [Fact]
+    public void GetBaseItemDtos_Items_ResolvePeopleFromBatch_WithoutPerItemLookup()
+    {
+        static MusicAlbum MakeAlbum() => new MusicAlbum
+        {
+            Id = Guid.NewGuid(),
+            Name = "Album",
+            ImageInfos = []
+        };
+
+        var albumOne = MakeAlbum();
+        var albumTwo = MakeAlbum();
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // DtoService resolves people for every item in ONE batch (GetPeopleByItems) before the
+        // per-item loop. A regression to the per-item path would call GetPeople(BaseItem) once per
+        // item (the N+1); it is intentionally left unset so such a regression fails here.
+        libraryManager
+            .Setup(x => x.GetPeopleByItems(It.IsAny<IReadOnlyList<Guid>>()))
+            .Returns(new Dictionary<Guid, IReadOnlyList<PersonInfo>>
+            {
+                [albumOne.Id] = [new PersonInfo { ItemId = albumOne.Id, Name = "Some Actor", Type = PersonKind.Actor }],
+                [albumTwo.Id] = [new PersonInfo { ItemId = albumTwo.Id, Name = "Some Actor", Type = PersonKind.Actor }]
+            });
+
+        // AttachPeople still resolves each distinct name to its Person entity to attach images.
+        libraryManager
+            .Setup(x => x.GetPerson("Some Actor"))
+            .Returns(new Person { Id = Guid.NewGuid(), Name = "Some Actor" });
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var options = new DtoOptions(false) { Fields = [ItemFields.People] };
+        var dtos = dtoService.GetBaseItemDtos([albumOne, albumTwo], options);
+
+        Assert.Equal(2, dtos.Count);
+        foreach (var dto in dtos)
+        {
+            Assert.NotNull(dto.People);
+            Assert.Single(dto.People);
+            Assert.Equal("Some Actor", dto.People[0].Name);
+        }
+
+        // People are batched once for the whole set, never once per item.
+        libraryManager.Verify(x => x.GetPeopleByItems(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+        libraryManager.Verify(x => x.GetPeople(It.IsAny<BaseItem>()), Times.Never);
+    }
+
+    [Fact]
+    public void GetBaseItemDtos_Videos_ResolveMediaSourceCountFromBatch_WithoutPerItemLookup()
+    {
+        static Movie MakeMovie() => new Movie
+        {
+            Id = Guid.NewGuid(),
+            Name = "Movie",
+            ImageInfos = []
+        };
+
+        var movieOne = MakeMovie();
+        var movieTwo = MakeMovie();
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // DtoService detects which videos own alternate versions in ONE batch
+        // (GetItemIdsWithAlternateVersions) before the per-item loop. Videos absent from that set have a
+        // single media source, so the per-item GetLinkedAlternateVersions/GetLocalAlternateVersionIds
+        // queries (the N+1) must be skipped entirely. Here neither movie has alternate versions.
+        libraryManager
+            .Setup(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()))
+            .Returns(new HashSet<Guid>());
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var options = new DtoOptions(false) { Fields = [ItemFields.MediaSourceCount] };
+        var dtos = dtoService.GetBaseItemDtos([movieOne, movieTwo], options);
+
+        Assert.Equal(2, dtos.Count);
+
+        // A single media source is the default, so the count is left unset (the client treats null as one).
+        foreach (var dto in dtos)
+        {
+            Assert.Null(dto.MediaSourceCount);
+        }
+
+        // The alternate-version check is batched once for the whole set, and the per-item lookups are
+        // never reached because the batch already ruled out alternate versions.
+        libraryManager.Verify(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+        libraryManager.Verify(x => x.GetLinkedAlternateVersions(It.IsAny<Video>()), Times.Never);
+        libraryManager.Verify(x => x.GetLocalAlternateVersionIds(It.IsAny<Video>()), Times.Never);
+    }
+
+    [Fact]
+    public void GetBaseItemDtos_VideoInAlternateVersionBatch_ResolvesRealCount()
+    {
+        var movie = new Movie
+        {
+            Id = Guid.NewGuid(),
+            Name = "Movie",
+            ImageInfos = []
+        };
+
+        var libraryManager = new Mock<ILibraryManager>();
+
+        // This movie IS in the batch set, so the fast path must not short-circuit it: the per-item
+        // lookups still run and the count is computed exactly as it was before batching. Two linked
+        // alternate versions plus the movie itself is a count of three.
+        libraryManager
+            .Setup(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()))
+            .Returns(new HashSet<Guid> { movie.Id });
+        libraryManager
+            .Setup(x => x.GetLinkedAlternateVersions(It.IsAny<Video>()))
+            .Returns([new Movie { Id = Guid.NewGuid() }, new Movie { Id = Guid.NewGuid() }]);
+        libraryManager
+            .Setup(x => x.GetLocalAlternateVersionIds(It.IsAny<Video>()))
+            .Returns([]);
+
+        var dtoService = BuildDtoService(libraryManager);
+
+        var options = new DtoOptions(false) { Fields = [ItemFields.MediaSourceCount] };
+        var dtos = dtoService.GetBaseItemDtos([movie], options);
+
+        Assert.Single(dtos);
+        Assert.Equal(3, dtos[0].MediaSourceCount);
+        libraryManager.Verify(x => x.GetItemIdsWithAlternateVersions(It.IsAny<IReadOnlyList<Guid>>()), Times.Once);
+    }
+
     private static DtoService BuildDtoService(BaseItem displayParent)
     {
         var libraryManager = new Mock<ILibraryManager>();
@@ -181,6 +310,10 @@ public class DtoServiceImageInheritanceTests
             .Setup(x => x.GetImageCacheTag(It.IsAny<BaseItem>(), It.IsAny<ItemImageInfo>()))
             .Returns<BaseItem, ItemImageInfo>((_, image) => image.Path);
 
+        // Video.IsActiveRecording() dereferences this static during DTO building.
+        Video.RecordingsManager = recordingsManager.Object;
+        BaseItem.LibraryManager = libraryManager.Object;
+
         return new DtoService(
             logger.Object,
             libraryManager.Object,
diff --git a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
index 9c247d54b9..bdac59c013 100644
--- a/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
+++ b/tests/Jellyfin.Server.Implementations.Tests/Dto/DtoServiceTests.cs
@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Generic;
 using Emby.Server.Implementations.Dto;
+using Jellyfin.Database.Implementations.Entities;
 using MediaBrowser.Common;
 using MediaBrowser.Controller.Chapters;
 using MediaBrowser.Controller.Drawing;
@@ -21,11 +23,13 @@ namespace Jellyfin.Server.Implementations.Tests.Dto;
 public class DtoServiceTests
 {
     private readonly Mock<ILibraryManager> _libraryManagerMock;
+    private readonly Mock<IUserDataManager> _userDataManagerMock;
     private readonly DtoService _dtoService;
 
     public DtoServiceTests()
     {
         _libraryManagerMock = new Mock<ILibraryManager>();
+        _userDataManagerMock = new Mock<IUserDataManager>();
 
         var imageProcessor = new Mock<IImageProcessor>();
         // Deterministic tag derived from the image so each item gets a distinct, assertable tag.
@@ -42,7 +46,7 @@ public class DtoServiceTests
         _dtoService = new DtoService(
             NullLogger<DtoService>.Instance,
             _libraryManagerMock.Object,
-            new Mock<IUserDataManager>().Object,
+            _userDataManagerMock.Object,
             imageProcessor.Object,
             new Mock<IProviderManager>().Object,
             new Mock<IRecordingsManager>().Object,
@@ -105,6 +109,57 @@ public class DtoServiceTests
         Assert.Null(dto.ParentPrimaryImageItemId);
     }
 
+    [Fact]
+    public void GetBaseItemDtos_SeasonWithNoRealEpisodes_ReportsVirtualEpisodesAsChildCount()
+    {
+        // No episode has aired yet, so RecursiveItemCount is 0. ChildCount must still report the
+        // virtual episodes clients get back for the season. This deliberately does not track
+        // Season.IsVirtualItem: that flag is recomputed only on a full refresh, so a season can
+        // carry it while already holding real episodes.
+        var (season, user) = BuildSeason(playedCount: 0, totalCount: 0, childCount: 10);
+        var options = new DtoOptions(false) { EnableImages = false, Fields = [ItemFields.ChildCount, ItemFields.RecursiveItemCount] };
+
+        var dto = _dtoService.GetBaseItemDtos([season], options, user, skipVisibilityCheck: true)[0];
+
+        Assert.Equal(0, dto.RecursiveItemCount);
+        Assert.Equal(10, dto.ChildCount);
+    }
+
+    [Fact]
+    public void GetBaseItemDtos_SeasonWithRealEpisodes_KeepsRecursiveItemCountAsChildCount()
+    {
+        var (season, user) = BuildSeason(playedCount: 2, totalCount: 9, childCount: 11);
+        var options = new DtoOptions(false) { EnableImages = false, Fields = [ItemFields.ChildCount, ItemFields.RecursiveItemCount] };
+
+        var dto = _dtoService.GetBaseItemDtos([season], options, user, skipVisibilityCheck: true)[0];
+
+        Assert.Equal(9, dto.RecursiveItemCount);
+        // The shortcut still wins over the batched child count, which also counts virtual episodes.
+        Assert.Equal(9, dto.ChildCount);
+    }
+
+    private (Season Season, User User) BuildSeason(int playedCount, int totalCount, int childCount)
+    {
+        var user = new User("user", "auth-provider", "reset-provider");
+        var season = new Season { Id = Guid.NewGuid(), Name = "Season 2", SeriesId = Guid.NewGuid() };
+
+        _userDataManagerMock
+            .Setup(x => x.GetUserDataBatch(It.IsAny<IReadOnlyList<BaseItem>>(), user))
+            .Returns(new Dictionary<Guid, UserItemData> { [season.Id] = new UserItemData { Key = "key" } });
+        _userDataManagerMock
+            .Setup(x => x.GetResumeUserDataBatch(It.IsAny<IReadOnlyList<BaseItem>>(), user))
+            .Returns(new Dictionary<Guid, VersionResumeData>());
+
+        _libraryManagerMock
+            .Setup(x => x.GetPlayedAndTotalCountBatch(It.IsAny<IReadOnlyList<Guid>>(), user))
+            .Returns(new Dictionary<Guid, (int Played, int Total)> { [season.Id] = (playedCount, totalCount) });
+        _libraryManagerMock
+            .Setup(x => x.GetChildCountBatch(It.IsAny<IReadOnlyList<Guid>>(), It.IsAny<Guid?>()))
+            .Returns(new Dictionary<Guid, int> { [season.Id] = childCount });
+
+        return (season, user);
+    }
+
     private (Episode Episode, Season Season, Series Series) BuildEpisode(bool seasonHasPoster, bool seriesHasPoster = true)
     {
         // Non-local (http) paths keep aspect-ratio resolution off the image processor and on the