test(api): pin mirror-offset guide behavior; clarify guide end-default wording (#102)

- Add GetChannelGuideDataHandlerTests coverage for the mirror-channel path:
  asserts programme Start/Stop shift by PlayoutOffset and that the source
  channel's seeded PlayoutItem entities are not mutated, pinning the
  WithPlayoutOffset copy fix.
- ChannelController.GetGuide Swagger description said end defaults to "now
  plus XmltvDaysToBuild"; it actually defaults to start plus that window
  (matters when start is supplied). Reworded and regenerated v1.json.

AGENTS.md

@@ -0,0 +1,15 @@
+# Codex Instructions
+
+## Verification Commands
+
+Run .NET restore, build, and test commands outside the sandbox by default in this repo. Sandboxed .NET commands can stall on NuGet/package/compiler cache access, while the same commands complete normally with approved unsandboxed execution.
+
+Preferred verification commands:
+
+```bash
+TZ=UTC dotnet restore ErsatzTV.sln -v minimal
+TZ=UTC dotnet build ErsatzTV.sln --no-restore -v minimal
+TZ=UTC dotnet test ErsatzTV.sln --no-build -v minimal
+```
+
+Use scoped escalated execution for these commands rather than first trying a sandboxed run.

ErsatzTV.Application/Artworks/Commands/UploadArtwork.cs

@@ -0,0 +1,13 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Artworks;
+
+/// <summary>
+///     Validates and stores an uploaded image as channel logo or watermark artwork,
+///     landing it in the same on-disk cache the Blazor UI uses (via <c>IImageCache</c>),
+///     so the returned path is equivalent to a Blazor-uploaded image.
+/// </summary>
+public record UploadArtwork(Stream Stream, string ContentType, ArtworkKind ArtworkKind)
+    : IRequest<Either<BaseError, ArtworkUploadResponseModel>>;

ErsatzTV.Application/Artworks/Commands/UploadArtworkHandler.cs

@@ -0,0 +1,53 @@
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Images;
+
+namespace ErsatzTV.Application.Artworks;
+
+public class UploadArtworkHandler : IRequestHandler<UploadArtwork, Either<BaseError, ArtworkUploadResponseModel>>
+{
+    // png/jpeg/gif/webp are all decoded by SkiaSharp and read by FFmpeg, matching the
+    // formats the Blazor logo/watermark upload already accepts. Format expansion is ersatztv#66.
+    private static readonly System.Collections.Generic.HashSet<string> AcceptedContentTypes = new(StringComparer.OrdinalIgnoreCase)
+    {
+        "image/png",
+        "image/jpeg",
+        "image/gif",
+        "image/webp"
+    };
+
+    private readonly IImageCache _imageCache;
+
+    public UploadArtworkHandler(IImageCache imageCache) => _imageCache = imageCache;
+
+    public async Task<Either<BaseError, ArtworkUploadResponseModel>> Handle(
+        UploadArtwork request,
+        CancellationToken cancellationToken)
+    {
+        string contentType = (request.ContentType ?? string.Empty).Trim();
+        if (!AcceptedContentTypes.Contains(contentType))
+        {
+            return BaseError.New(
+                $"Unsupported image content type '{contentType}'; supported types are: {string.Join(", ", AcceptedContentTypes)}");
+        }
+
+        Either<BaseError, string> maybeFileName = await _imageCache.SaveArtworkToCache(
+            request.Stream,
+            request.ArtworkKind);
+
+        return maybeFileName.Map(fileName => new ArtworkUploadResponseModel(
+            BuildPath(request.ArtworkKind, fileName),
+            contentType));
+    }
+
+    // Mirror the on-disk conventions the Blazor editors use so the returned path is a drop-in
+    // for ArtworkContentTypeModel.Path: channel logos are addressed as "iptv/logos/{file}"
+    // (see ChannelEditor.UploadLogo), watermarks by the bare cache file name (see WatermarkEditor).
+    private static string BuildPath(ArtworkKind artworkKind, string fileName) =>
+        artworkKind switch
+        {
+            ArtworkKind.Logo => $"iptv/logos/{fileName}",
+            _ => fileName
+        };
+}

ErsatzTV.Application/Channels/ChannelGuideMetadata.cs

@@ -0,0 +1,71 @@
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     Shared programme-metadata projection for guide output. Both the XMLTV cache builder
+///     (<see cref="RefreshChannelDataHandler" />) and the JSON guide query
+///     (<see cref="GetChannelGuideDataHandler" />) resolve the display title/subtitle/category from a
+///     <see cref="PlayoutItem" /> here so the two representations stay consistent.
+/// </summary>
+public static class ChannelGuideMetadata
+{
+    public static string GetTitle(PlayoutItem playoutItem)
+    {
+        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+        {
+            return playoutItem.CustomTitle;
+        }
+
+        return playoutItem.MediaItem switch
+        {
+            Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title ?? string.Empty)
+                .IfNone("[unknown movie]"),
+            Episode e => e.Season.Show.ShowMetadata.HeadOrNone().Map(em => em.Title ?? string.Empty)
+                .IfNone("[unknown show]"),
+            MusicVideo mv => mv.Artist.ArtistMetadata.HeadOrNone().Map(am => am.Title ?? string.Empty)
+                .IfNone("[unknown artist]"),
+            OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
+                .IfNone("[unknown video]"),
+            RemoteStream rs => rs.RemoteStreamMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
+                .IfNone("[unknown remote stream]"),
+            _ => "[unknown]"
+        };
+    }
+
+    public static string GetSubtitle(PlayoutItem playoutItem)
+    {
+        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
+        {
+            return string.Empty;
+        }
+
+        return playoutItem.MediaItem switch
+        {
+            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
+                em => em.Title ?? string.Empty,
+                () => string.Empty),
+            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
+                mvm => mvm.Title ?? string.Empty,
+                () => string.Empty),
+            Song s => s.SongMetadata.HeadOrNone().Match(
+                mvm => mvm.Title ?? string.Empty,
+                () => string.Empty),
+            _ => string.Empty
+        };
+    }
+
+    /// <summary>
+    ///     The primary guide category, mirroring the fixed <c>&lt;category&gt;</c> the XMLTV templates
+    ///     emit per media kind (Movie / Series / Music). Media kinds without a fixed category return null.
+    /// </summary>
+    public static string GetCategory(PlayoutItem playoutItem) =>
+        playoutItem.MediaItem switch
+        {
+            Movie => "Movie",
+            Episode => "Series",
+            MusicVideo => "Music",
+            Song => "Music",
+            _ => null
+        };
+}

ErsatzTV.Application/Channels/ChannelGuideProjector.cs

@@ -0,0 +1,164 @@
+using ErsatzTV.Application.Configuration;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     A single guide programme resolved from one or more <see cref="PlayoutItem" />s: the
+///     <see cref="DisplayItem" /> whose metadata is shown, plus the coalesced <see cref="Start" />/
+///     <see cref="Stop" /> window and whether the originating item carried a custom title.
+/// </summary>
+public readonly record struct ChannelGuideEntry(
+    PlayoutItem DisplayItem,
+    DateTimeOffset Start,
+    DateTimeOffset Stop,
+    bool HasCustomTitle);
+
+/// <summary>
+///     Shared guide-group / filler-merge projection. This is the single source of truth for turning a
+///     channel's sorted <see cref="PlayoutItem" />s into guide programmes; both the XMLTV cache builder
+///     (<see cref="RefreshChannelDataHandler" />) and the JSON guide query
+///     (<see cref="GetChannelGuideDataHandler" />) consume it so the two representations cannot drift.
+///     The XMLTV path formats <see cref="ChannelGuideEntry.Start" />/<see cref="ChannelGuideEntry.Stop" />
+///     into the XMLTV timestamp strings; the JSON path returns them (and the display item's
+///     <see cref="FillerKind" />) directly and lets the UI decide how to render filler.
+/// </summary>
+public static class ChannelGuideProjector
+{
+    public static IEnumerable<ChannelGuideEntry> Project(
+        PlayoutScheduleKind scheduleKind,
+        IReadOnlyList<PlayoutItem> sorted,
+        XmltvTimeZone timeZone,
+        XmltvBlockBehavior blockBehavior) =>
+        scheduleKind switch
+        {
+            PlayoutScheduleKind.Block => ProjectBlock(sorted, timeZone, blockBehavior),
+            _ => ProjectFlood(sorted, timeZone)
+        };
+
+    // Classic / Sequential / Scripted / ExternalJson: skip leading non-preroll filler, then coalesce
+    // each guide group (following filler) into a single programme using the display item's GuideFinish
+    // override when present.
+    private static IEnumerable<ChannelGuideEntry> ProjectFlood(
+        IReadOnlyList<PlayoutItem> sorted,
+        XmltvTimeZone timeZone)
+    {
+        // skip all filler that isn't pre-roll
+        var i = 0;
+        while (i < sorted.Count && sorted[i].FillerKind != FillerKind.None &&
+               sorted[i].FillerKind != FillerKind.PreRoll)
+        {
+            i++;
+        }
+
+        while (i < sorted.Count)
+        {
+            PlayoutItem startItem = sorted[i];
+            int j = i;
+            while (sorted[j].FillerKind != FillerKind.None && j + 1 < sorted.Count)
+            {
+                j++;
+            }
+
+            PlayoutItem displayItem = sorted[j];
+            bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
+
+            int finishIndex = j;
+            while (finishIndex + 1 < sorted.Count && (sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup
+                                                      || sorted[finishIndex + 1].FillerKind is FillerKind.GuideMode
+                                                          or FillerKind.PostRoll or FillerKind.Tail
+                                                          or FillerKind.Fallback or FillerKind.DecoDefault))
+            {
+                finishIndex++;
+            }
+
+            PlayoutItem finishItem = sorted[finishIndex];
+            i = finishIndex;
+
+            DateTimeOffset startTime = timeZone switch
+            {
+                XmltvTimeZone.Utc => new DateTimeOffset(startItem.Start, TimeSpan.Zero),
+                _ => startItem.StartOffset
+            };
+
+            DateTimeOffset stopTime = (timeZone, displayItem.GuideFinishOffset.HasValue) switch
+            {
+                (XmltvTimeZone.Utc, true) => new DateTimeOffset(displayItem.GuideFinish!.Value, TimeSpan.Zero),
+                (XmltvTimeZone.Utc, false) => new DateTimeOffset(finishItem.Finish, TimeSpan.Zero),
+                (_, true) => displayItem.GuideFinishOffset!.Value,
+                (_, false) => finishItem.FinishOffset
+            };
+
+            yield return new ChannelGuideEntry(displayItem, startTime, stopTime, hasCustomTitle);
+
+            i++;
+        }
+    }
+
+    // Block: group by guide window, drop filler entirely, then either use the items' actual times or
+    // split the group window evenly across the non-filler items.
+    private static IEnumerable<ChannelGuideEntry> ProjectBlock(
+        IReadOnlyList<PlayoutItem> sorted,
+        XmltvTimeZone timeZone,
+        XmltvBlockBehavior blockBehavior)
+    {
+        var groups = sorted.GroupBy(s => new { s.GuideStart, s.GuideFinish, s.GuideGroup });
+        foreach (var group in groups)
+        {
+            var itemsToInclude = group.Filter(g => g.FillerKind is FillerKind.None).ToList();
+            if (itemsToInclude.Count == 0)
+            {
+                continue;
+            }
+
+            switch (blockBehavior)
+            {
+                case XmltvBlockBehavior.UseActualTimes:
+                    foreach (PlayoutItem item in itemsToInclude)
+                    {
+                        DateTimeOffset actualStart = timeZone switch
+                        {
+                            XmltvTimeZone.Utc => new DateTimeOffset(item.Start, TimeSpan.Zero),
+                            _ => new DateTimeOffset(item.Start, TimeSpan.Zero).ToLocalTime()
+                        };
+
+                        DateTimeOffset actualFinish = timeZone switch
+                        {
+                            XmltvTimeZone.Utc => new DateTimeOffset(item.Finish, TimeSpan.Zero),
+                            _ => new DateTimeOffset(item.Finish, TimeSpan.Zero).ToLocalTime()
+                        };
+
+                        yield return new ChannelGuideEntry(item, actualStart, actualFinish, false);
+                    }
+
+                    break;
+                case XmltvBlockBehavior.SplitTimeEvenly:
+                default:
+                    DateTime groupStart = group.Key.GuideStart!.Value;
+                    DateTime groupFinish = group.Key.GuideFinish!.Value;
+                    TimeSpan groupDuration = groupFinish - groupStart;
+
+                    TimeSpan perItem = groupDuration / itemsToInclude.Count;
+
+                    DateTimeOffset currentStart = timeZone switch
+                    {
+                        XmltvTimeZone.Utc => new DateTimeOffset(groupStart, TimeSpan.Zero),
+                        _ => new DateTimeOffset(groupStart, TimeSpan.Zero).ToLocalTime()
+                    };
+
+                    DateTimeOffset currentFinish = currentStart + perItem;
+
+                    foreach (PlayoutItem item in itemsToInclude)
+                    {
+                        yield return new ChannelGuideEntry(item, currentStart, currentFinish, false);
+
+                        currentStart = currentFinish;
+                        currentFinish += perItem;
+                    }
+
+                    break;
+            }
+        }
+    }
+}

ErsatzTV.Application/Channels/Commands/RefreshChannelDataHandler.cs

@@ -129,89 +129,7 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
             List<Playout> playouts = await dbContext.Playouts
                 .AsNoTracking()
                 .Filter(pi => pi.Channel.Number == (mirrorChannelNumber ?? request.ChannelNumber))
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).EpisodeMetadata)
-                .ThenInclude(em => em.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Episode).Season)
-                .ThenInclude(s => s.Show)
-                .ThenInclude(s => s.ShowMetadata)
-                .ThenInclude(sm => sm.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Movie).MovieMetadata)
-                .ThenInclude(mm => mm.Guids)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mm => mm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Studios)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Directors)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
-                .ThenInclude(mvm => mvm.Artists)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as MusicVideo).Artist)
-                .ThenInclude(a => a.ArtistMetadata)
-                .ThenInclude(am => am.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as RemoteStream).RemoteStreamMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(vm => vm.Artwork)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(sm => sm.Genres)
-                .Include(p => p.Items)
-                .ThenInclude(i => i.MediaItem)
-                .ThenInclude(i => (i as Song).SongMetadata)
-                .ThenInclude(sm => sm.Studios)
+                .IncludeGuideMetadata()
                 .AsSplitQuery()
                 .ToListAsync(cancellationToken);
 
@@ -244,8 +162,9 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                             item.Finish += playoutOffset;
                         }
 
-                        await WritePlayoutXml(
+                        await WriteScheduleXml(
                             request,
+                            playout.ScheduleKind,
                             floodSorted,
                             templateContext,
                             movieTemplate,
@@ -270,8 +189,9 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                             item.Finish += playoutOffset;
                         }
 
-                        await WriteBlockPlayoutXml(
+                        await WriteScheduleXml(
                             request,
+                            playout.ScheduleKind,
                             blockSorted,
                             templateContext,
                             movieTemplate,
@@ -294,8 +214,9 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
                             item.Finish += playoutOffset;
                         }
 
-                        await WritePlayoutXml(
+                        await WriteScheduleXml(
                             request,
+                            playout.ScheduleKind,
                             externalJsonSorted,
                             templateContext,
                             movieTemplate,
@@ -324,100 +245,9 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         }
     }
 
-    private async Task WritePlayoutXml(
-        RefreshChannelData request,
-        List<PlayoutItem> sorted,
-        XmlTemplateContext templateContext,
-        Template movieTemplate,
-        Template episodeTemplate,
-        Template musicVideoTemplate,
-        Template songTemplate,
-        Template otherVideoTemplate,
-        Template remoteStreamTemplate,
-        XmlMinifier minifier,
-        XmlWriter xml,
-        CancellationToken cancellationToken)
-    {
-        XmltvTimeZone xmltvTimeZone = await _configElementRepository
-            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken)
-            .IfNoneAsync(XmltvTimeZone.Local);
-
-        // skip all filler that isn't pre-roll
-        var i = 0;
-        while (i < sorted.Count && sorted[i].FillerKind != FillerKind.None &&
-               sorted[i].FillerKind != FillerKind.PreRoll)
-        {
-            i++;
-        }
-
-        while (i < sorted.Count)
-        {
-            PlayoutItem startItem = sorted[i];
-            int j = i;
-            while (sorted[j].FillerKind != FillerKind.None && j + 1 < sorted.Count)
-            {
-                j++;
-            }
-
-            PlayoutItem displayItem = sorted[j];
-            bool hasCustomTitle = !string.IsNullOrWhiteSpace(startItem.CustomTitle);
-
-            int finishIndex = j;
-            while (finishIndex + 1 < sorted.Count && (sorted[finishIndex + 1].GuideGroup == startItem.GuideGroup
-                                                      || sorted[finishIndex + 1].FillerKind is FillerKind.GuideMode
-                                                          or FillerKind.PostRoll or FillerKind.Tail
-                                                          or FillerKind.Fallback or FillerKind.DecoDefault))
-            {
-                finishIndex++;
-            }
-
-            PlayoutItem finishItem = sorted[finishIndex];
-            i = finishIndex;
-
-            DateTimeOffset startTime = xmltvTimeZone switch
-            {
-                XmltvTimeZone.Utc => new DateTimeOffset(startItem.Start, TimeSpan.Zero),
-                _ => startItem.StartOffset
-            };
-
-            DateTimeOffset stopTime = (xmltvTimeZone, displayItem.GuideFinishOffset.HasValue) switch
-            {
-                (XmltvTimeZone.Utc, true) => new DateTimeOffset(displayItem.GuideFinish!.Value, TimeSpan.Zero),
-                (XmltvTimeZone.Utc, false) => new DateTimeOffset(finishItem.Finish, TimeSpan.Zero),
-                (_, true) => displayItem.GuideFinishOffset!.Value,
-                (_, false) => finishItem.FinishOffset
-            };
-
-            string start = startTime
-                .ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                .Replace(":", string.Empty);
-
-            string stop = stopTime
-                .ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                .Replace(":", string.Empty);
-
-            await WriteItemToXml(
-                request,
-                displayItem,
-                start,
-                stop,
-                hasCustomTitle,
-                templateContext,
-                movieTemplate,
-                episodeTemplate,
-                musicVideoTemplate,
-                songTemplate,
-                otherVideoTemplate,
-                remoteStreamTemplate,
-                minifier,
-                xml);
-
-            i++;
-        }
-    }
-
-    private async Task WriteBlockPlayoutXml(
+    private async Task WriteScheduleXml(
         RefreshChannelData request,
+        PlayoutScheduleKind scheduleKind,
         List<PlayoutItem> sorted,
         XmlTemplateContext templateContext,
         Template movieTemplate,
@@ -438,98 +268,36 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
             .GetValue<XmltvBlockBehavior>(ConfigElementKey.XmltvBlockBehavior, cancellationToken)
             .IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly);
 
-        var groups = sorted.GroupBy(s => new { s.GuideStart, s.GuideFinish, s.GuideGroup });
-        foreach (var group in groups)
+        // guide-group / filler-merge logic is shared with the JSON guide query so the two cannot drift
+        foreach (ChannelGuideEntry entry in ChannelGuideProjector.Project(
+                     scheduleKind,
+                     sorted,
+                     xmltvTimeZone,
+                     xmltvBlockBehavior))
         {
-            var itemsToInclude = group.Filter(g => g.FillerKind is FillerKind.None).ToList();
-            if (itemsToInclude.Count == 0)
-            {
-                continue;
-            }
+            string start = entry.Start
+                .ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                .Replace(":", string.Empty);
 
-            switch (xmltvBlockBehavior)
-            {
-                case XmltvBlockBehavior.UseActualTimes:
-                    foreach (PlayoutItem item in itemsToInclude)
-                    {
-                        DateTimeOffset actualStart = xmltvTimeZone switch
-                        {
-                            XmltvTimeZone.Utc => new DateTimeOffset(item.Start, TimeSpan.Zero),
-                            _ => new DateTimeOffset(item.Start, TimeSpan.Zero).ToLocalTime()
-                        };
+            string stop = entry.Stop
+                .ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
+                .Replace(":", string.Empty);
 
-                        DateTimeOffset actualFinish = xmltvTimeZone switch
-                        {
-                            XmltvTimeZone.Utc => new DateTimeOffset(item.Finish, TimeSpan.Zero),
-                            _ => new DateTimeOffset(item.Finish, TimeSpan.Zero).ToLocalTime()
-                        };
-
-                        string start = actualStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-                        string stop = actualFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-
-                        await WriteItemToXml(
-                            request,
-                            item,
-                            start,
-                            stop,
-                            false,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml);
-                    }
-                    break;
-                case XmltvBlockBehavior.SplitTimeEvenly:
-                default:
-                    DateTime groupStart = group.Key.GuideStart!.Value;
-                    DateTime groupFinish = group.Key.GuideFinish!.Value;
-                    TimeSpan groupDuration = groupFinish - groupStart;
-
-                    TimeSpan perItem = groupDuration / itemsToInclude.Count;
-
-                    DateTimeOffset currentStart = xmltvTimeZone switch
-                    {
-                        XmltvTimeZone.Utc => new DateTimeOffset(groupStart, TimeSpan.Zero),
-                        _ => new DateTimeOffset(groupStart, TimeSpan.Zero).ToLocalTime()
-                    };
-
-                    DateTimeOffset currentFinish = currentStart + perItem;
-
-                    foreach (PlayoutItem item in itemsToInclude)
-                    {
-                        string start = currentStart.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-                        string stop = currentFinish.ToString("yyyyMMddHHmmss zzz", CultureInfo.InvariantCulture)
-                            .Replace(":", string.Empty);
-
-                        await WriteItemToXml(
-                            request,
-                            item,
-                            start,
-                            stop,
-                            false,
-                            templateContext,
-                            movieTemplate,
-                            episodeTemplate,
-                            musicVideoTemplate,
-                            songTemplate,
-                            otherVideoTemplate,
-                            remoteStreamTemplate,
-                            minifier,
-                            xml);
-
-                        currentStart = currentFinish;
-                        currentFinish += perItem;
-                    }
-                    break;
-            }
+            await WriteItemToXml(
+                request,
+                entry.DisplayItem,
+                start,
+                stop,
+                entry.HasCustomTitle,
+                templateContext,
+                movieTemplate,
+                episodeTemplate,
+                musicVideoTemplate,
+                songTemplate,
+                otherVideoTemplate,
+                remoteStreamTemplate,
+                minifier,
+                xml);
         }
     }
 
@@ -549,8 +317,8 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         XmlMinifier minifier,
         XmlWriter xml)
     {
-        string title = GetTitle(displayItem);
-        string subtitle = GetSubtitle(displayItem);
+        string title = ChannelGuideMetadata.GetTitle(displayItem);
+        string subtitle = ChannelGuideMetadata.GetSubtitle(displayItem);
 
         Option<string> maybeTemplateOutput = displayItem.MediaItem switch
         {
@@ -1117,51 +885,6 @@ public class RefreshChannelDataHandler : IRequestHandler<RefreshChannelData>
         return artworkPath;
     }
 
-    private static string GetTitle(PlayoutItem playoutItem)
-    {
-        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
-        {
-            return playoutItem.CustomTitle;
-        }
-
-        return playoutItem.MediaItem switch
-        {
-            Movie m => m.MovieMetadata.HeadOrNone().Map(mm => mm.Title ?? string.Empty)
-                .IfNone("[unknown movie]"),
-            Episode e => e.Season.Show.ShowMetadata.HeadOrNone().Map(em => em.Title ?? string.Empty)
-                .IfNone("[unknown show]"),
-            MusicVideo mv => mv.Artist.ArtistMetadata.HeadOrNone().Map(am => am.Title ?? string.Empty)
-                .IfNone("[unknown artist]"),
-            OtherVideo ov => ov.OtherVideoMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
-                .IfNone("[unknown video]"),
-            RemoteStream rs => rs.RemoteStreamMetadata.HeadOrNone().Map(vm => vm.Title ?? string.Empty)
-                .IfNone("[unknown remote stream]"),
-            _ => "[unknown]"
-        };
-    }
-
-    private static string GetSubtitle(PlayoutItem playoutItem)
-    {
-        if (!string.IsNullOrWhiteSpace(playoutItem.CustomTitle))
-        {
-            return string.Empty;
-        }
-
-        return playoutItem.MediaItem switch
-        {
-            Episode e => e.EpisodeMetadata.HeadOrNone().Match(
-                em => em.Title ?? string.Empty,
-                () => string.Empty),
-            MusicVideo mv => mv.MusicVideoMetadata.HeadOrNone().Match(
-                mvm => mvm.Title ?? string.Empty,
-                () => string.Empty),
-            Song s => s.SongMetadata.HeadOrNone().Match(
-                mvm => mvm.Title ?? string.Empty,
-                () => string.Empty),
-            _ => string.Empty
-        };
-    }
-
     private static string GetPrioritizedArtworkPath(Metadata metadata)
     {
         Option<string> maybeArtwork = Optional(metadata.Artwork).Flatten()

ErsatzTV.Application/Channels/Queries/GetChannelGuideData.cs

@@ -0,0 +1,10 @@
+using ErsatzTV.Core.Api.Channels;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     JSON channel-guide query for the EPG grid. <paramref name="Start" /> defaults to now and
+///     <paramref name="End" /> defaults to now + the configured XmltvDaysToBuild window.
+/// </summary>
+public record GetChannelGuideData(DateTimeOffset? Start, DateTimeOffset? End)
+    : IRequest<ChannelGuideResponseModel>;

ErsatzTV.Application/Channels/Queries/GetChannelGuideDataHandler.cs

@@ -0,0 +1,145 @@
+using System.Globalization;
+using ErsatzTV.Application.Configuration;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Infrastructure.Extensions;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.Channels;
+
+/// <summary>
+///     Builds the JSON channel guide directly from <see cref="Playout" /> items, using the shared
+///     <see cref="ChannelGuideProjector" /> guide-group/filler-merge logic (the same logic the XMLTV
+///     cache builder uses) so the two representations cannot drift. Only channels with
+///     <see cref="Channel.ShowInEpg" /> are included, mirroring <c>GetChannelGuideHandler</c>.
+///     Unlike XMLTV, filler programmes are returned (with their <see cref="Core.Domain.Filler.FillerKind" />)
+///     so the UI can decide how to render them.
+/// </summary>
+public class GetChannelGuideDataHandler(
+    IDbContextFactory<TvContext> dbContextFactory,
+    IConfigElementRepository configElementRepository)
+    : IRequestHandler<GetChannelGuideData, ChannelGuideResponseModel>
+{
+    public async Task<ChannelGuideResponseModel> Handle(
+        GetChannelGuideData request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        int daysToBuild = await configElementRepository
+            .GetValue<int>(ConfigElementKey.XmltvDaysToBuild, cancellationToken)
+            .IfNoneAsync(2);
+
+        XmltvTimeZone xmltvTimeZone = await configElementRepository
+            .GetValue<XmltvTimeZone>(ConfigElementKey.XmltvTimeZone, cancellationToken)
+            .IfNoneAsync(XmltvTimeZone.Local);
+
+        XmltvBlockBehavior xmltvBlockBehavior = await configElementRepository
+            .GetValue<XmltvBlockBehavior>(ConfigElementKey.XmltvBlockBehavior, cancellationToken)
+            .IfNoneAsync(XmltvBlockBehavior.SplitTimeEvenly);
+
+        DateTimeOffset start = request.Start ?? DateTimeOffset.UtcNow;
+        DateTimeOffset end = request.End ?? start.AddDays(daysToBuild);
+
+        // Visible channels only (mirror GetChannelGuideHandler's ShowInEpg == false skip).
+        List<Channel> channels = await dbContext.Channels
+            .AsNoTracking()
+            .Where(c => c.ShowInEpg)
+            .Include(c => c.MirrorSourceChannel)
+            .ToListAsync(cancellationToken);
+
+        // Order channels by their decimal channel number so "2" precedes "10", matching
+        // ChannelGuide.ToXml (which orders XMLTV channels by decimal.Parse of the number).
+        channels = channels
+            .OrderBy(c => decimal.Parse(c.Number, CultureInfo.InvariantCulture))
+            .ToList();
+
+        var responseChannels = new List<ChannelGuideChannelResponseModel>();
+
+        foreach (Channel channel in channels)
+        {
+            bool isMirror = channel.PlayoutSource == ChannelPlayoutSource.Mirror
+                && channel.MirrorSourceChannel is not null;
+
+            string sourceChannelNumber = isMirror ? channel.MirrorSourceChannel.Number : channel.Number;
+            TimeSpan playoutOffset = isMirror ? channel.PlayoutOffset ?? TimeSpan.Zero : TimeSpan.Zero;
+
+            List<Playout> playouts = await dbContext.Playouts
+                .AsNoTracking()
+                .Filter(p => p.Channel.Number == sourceChannelNumber)
+                .IncludeGuideMetadata()
+                .AsSplitQuery()
+                .ToListAsync(cancellationToken);
+
+            var programmes = new List<ChannelGuideProgrammeResponseModel>();
+
+            foreach (Playout playout in playouts)
+            {
+                // ExternalJson playouts materialize items from a file rather than Playout.Items; they are
+                // out of scope for the JSON guide (see issue #102 notes).
+                if (playout.ScheduleKind is PlayoutScheduleKind.ExternalJson)
+                {
+                    continue;
+                }
+
+                // Filter to the window (on the pre-offset time, mirroring the XMLTV builder) then apply the
+                // mirror playout offset without mutating the loaded (shared, AsNoTracking) entities.
+                List<PlayoutItem> sorted = playout.Items
+                    .OrderBy(pi => pi.Start)
+                    .Filter(pi => pi.StartOffset <= end)
+                    .Select(pi => playoutOffset == TimeSpan.Zero ? pi : WithPlayoutOffset(pi, playoutOffset))
+                    .ToList();
+
+                foreach (ChannelGuideEntry entry in ChannelGuideProjector.Project(
+                             playout.ScheduleKind,
+                             sorted,
+                             xmltvTimeZone,
+                             xmltvBlockBehavior))
+                {
+                    // drop programmes that finish before the requested window starts
+                    if (entry.Stop <= start)
+                    {
+                        continue;
+                    }
+
+                    string subtitle = ChannelGuideMetadata.GetSubtitle(entry.DisplayItem);
+
+                    programmes.Add(
+                        new ChannelGuideProgrammeResponseModel(
+                            entry.Start,
+                            entry.Stop,
+                            ChannelGuideMetadata.GetTitle(entry.DisplayItem),
+                            string.IsNullOrWhiteSpace(subtitle) ? null : subtitle,
+                            ChannelGuideMetadata.GetCategory(entry.DisplayItem),
+                            entry.DisplayItem.FillerKind));
+                }
+            }
+
+            responseChannels.Add(
+                new ChannelGuideChannelResponseModel(
+                    channel.Number,
+                    channel.Name,
+                    programmes.OrderBy(p => p.Start).ToList()));
+        }
+
+        return new ChannelGuideResponseModel(start, end, responseChannels);
+    }
+
+    // Copy (don't mutate) the loaded PlayoutItem when shifting by the mirror playout offset. The loaded
+    // entities are AsNoTracking and shared; mutating them in place would corrupt the guide projection.
+    // Mirrors the XMLTV builder, which shifts only Start/Finish (not the Guide* window).
+    private static PlayoutItem WithPlayoutOffset(PlayoutItem item, TimeSpan offset) =>
+        new()
+        {
+            MediaItem = item.MediaItem,
+            Start = item.Start + offset,
+            Finish = item.Finish + offset,
+            GuideStart = item.GuideStart,
+            GuideFinish = item.GuideFinish,
+            GuideGroup = item.GuideGroup,
+            FillerKind = item.FillerKind,
+            CustomTitle = item.CustomTitle
+        };
+}

ErsatzTV.Application/Filler/Mapper.cs

@@ -1,9 +1,13 @@
-using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Api.Filler;
+using ErsatzTV.Core.Domain.Filler;
 
 namespace ErsatzTV.Application.Filler;
 
 internal static class Mapper
 {
+    internal static FillerPresetResponseModel ProjectToResponseModel(FillerPreset fillerPreset) =>
+        new(fillerPreset.Id, fillerPreset.Name);
+
     internal static FillerPresetViewModel ProjectToViewModel(FillerPreset fillerPreset) =>
         new(
             fillerPreset.Id,

ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Filler;
+
+namespace ErsatzTV.Application.Filler;
+
+public record GetAllFillerPresetsForApi : IRequest<List<FillerPresetResponseModel>>;

ErsatzTV.Application/Filler/Queries/GetAllFillerPresetsForApiHandler.cs

@@ -0,0 +1,22 @@
+using ErsatzTV.Core.Api.Filler;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Filler.Mapper;
+
+namespace ErsatzTV.Application.Filler;
+
+public class GetAllFillerPresetsForApiHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllFillerPresetsForApi, List<FillerPresetResponseModel>>
+{
+    public async Task<List<FillerPresetResponseModel>> Handle(
+        GetAllFillerPresetsForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        List<FillerPreset> fillerPresets = await dbContext.FillerPresets
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+        return fillerPresets.Map(ProjectToResponseModel).ToList();
+    }
+}

ErsatzTV.Application/Graphics/Queries/GetAllGraphicsElementsForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Graphics;
+
+namespace ErsatzTV.Application.Graphics;
+
+public record GetAllGraphicsElementsForApi : IRequest<List<GraphicsElementResponseModel>>;

ErsatzTV.Application/Graphics/Queries/GetAllGraphicsElementsForApiHandler.cs

@@ -0,0 +1,27 @@
+using ErsatzTV.Core.Api.Graphics;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Graphics.Mapper;
+
+namespace ErsatzTV.Application.Graphics;
+
+public class GetAllGraphicsElementsForApiHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllGraphicsElementsForApi, List<GraphicsElementResponseModel>>
+{
+    public async Task<List<GraphicsElementResponseModel>> Handle(
+        GetAllGraphicsElementsForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        List<GraphicsElement> graphicsElements = await dbContext.GraphicsElements
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+        return graphicsElements
+            .Map(ProjectToViewModel)
+            .OrderBy(e => e.Name == e.FileName)
+            .ThenBy(e => e.Name)
+            .Select(vm => new GraphicsElementResponseModel(vm.Id, vm.Name))
+            .ToList();
+    }
+}

ErsatzTV.Application/Health/Mapper.cs

@@ -0,0 +1,24 @@
+using ErsatzTV.Core.Api.Health;
+using ErsatzTV.Core.Health;
+
+namespace ErsatzTV.Application.Health;
+
+internal static class Mapper
+{
+    internal static HealthCheckResponseModel ProjectToResponseModel(HealthCheckResult result) =>
+        new(
+            result.Title,
+            GetStatus(result.Status),
+            result.Message,
+            result.Link.MatchUnsafe(l => l.Link, () => null));
+
+    private static string GetStatus(HealthCheckStatus status) =>
+        status switch
+        {
+            HealthCheckStatus.Pass => "pass",
+            HealthCheckStatus.Fail => "fail",
+            HealthCheckStatus.Warning => "warn",
+            HealthCheckStatus.Info => "info",
+            _ => throw new ArgumentOutOfRangeException(nameof(status), status, null)
+        };
+}

ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Health;
+
+namespace ErsatzTV.Application.Health;
+
+public record GetAllHealthCheckResultsForApi : IRequest<List<HealthCheckResponseModel>>;

ErsatzTV.Application/Health/Queries/GetAllHealthCheckResultsForApiHandler.cs

@@ -0,0 +1,32 @@
+using ErsatzTV.Core.Api.Health;
+using ErsatzTV.Core.Health;
+using static ErsatzTV.Application.Health.Mapper;
+
+namespace ErsatzTV.Application.Health;
+
+public class GetAllHealthCheckResultsForApiHandler
+    : IRequestHandler<GetAllHealthCheckResultsForApi, List<HealthCheckResponseModel>>
+{
+    private readonly IHealthCheckService _healthCheckService;
+
+    public GetAllHealthCheckResultsForApiHandler(IHealthCheckService healthCheckService) =>
+        _healthCheckService = healthCheckService;
+
+    public async Task<List<HealthCheckResponseModel>> Handle(
+        GetAllHealthCheckResultsForApi request,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            List<HealthCheckResult> results = await _healthCheckService.PerformHealthChecks(cancellationToken);
+            return results
+                .Filter(r => r.Status != HealthCheckStatus.NotApplicable)
+                .Map(ProjectToResponseModel)
+                .ToList();
+        }
+        catch (Exception ex) when (ex is TaskCanceledException or OperationCanceledException)
+        {
+            return [];
+        }
+    }
+}

ErsatzTV.Application/Libraries/Queries/GetLibraryScanStatus.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Libraries;
+
+namespace ErsatzTV.Application.Libraries;
+
+public record GetLibraryScanStatus : IRequest<List<LibraryScanStatusResponseModel>>;

ErsatzTV.Application/Libraries/Queries/GetLibraryScanStatusHandler.cs

@@ -0,0 +1,20 @@
+using ErsatzTV.Core.Api.Libraries;
+using ErsatzTV.Core.Interfaces.Metadata;
+using ErsatzTV.Core.Metadata;
+
+namespace ErsatzTV.Application.Libraries;
+
+public class GetLibraryScanStatusHandler(IScannerProxyService scannerProxyService)
+    : IRequestHandler<GetLibraryScanStatus, List<LibraryScanStatusResponseModel>>
+{
+    public Task<List<LibraryScanStatusResponseModel>> Handle(
+        GetLibraryScanStatus request,
+        CancellationToken cancellationToken)
+    {
+        List<LibraryScanStatusResponseModel> result = scannerProxyService.GetActiveScans()
+            .Select(scan => new LibraryScanStatusResponseModel(scan.LibraryId, scan.Progress))
+            .ToList();
+
+        return Task.FromResult(result);
+    }
+}

ErsatzTV.Application/MediaSources/Queries/GetAllMediaSourcesForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.MediaSources;
+
+namespace ErsatzTV.Application.MediaSources;
+
+public record GetAllMediaSourcesForApi : IRequest<List<MediaSourceResponseModel>>;

ErsatzTV.Application/MediaSources/Queries/GetAllMediaSourcesForApiHandler.cs

@@ -0,0 +1,148 @@
+#nullable enable
+using Dapper;
+using ErsatzTV.Core.Api.MediaSources;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Application.MediaSources;
+
+public class GetAllMediaSourcesForApiHandler(
+    IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllMediaSourcesForApi, List<MediaSourceResponseModel>>
+{
+    public async Task<List<MediaSourceResponseModel>> Handle(
+        GetAllMediaSourcesForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+
+        List<MediaSource> mediaSources = await dbContext.MediaSources
+                .AsNoTracking()
+                .Include(s => s.Libraries)
+                .ThenInclude(l => l.Paths)
+                .ToListAsync(cancellationToken);
+
+        Dictionary<int, int> itemCountsByLibrary = await GetItemCountsByLibrary(dbContext, cancellationToken);
+        Dictionary<int, string> addressByMediaSourceId = await GetConnectionAddresses(dbContext, cancellationToken);
+
+        var result = new List<MediaSourceResponseModel>();
+        foreach (MediaSource mediaSource in mediaSources)
+        {
+            List<MediaSourceLibraryResponseModel> libraryModels = mediaSource.Libraries
+                .Filter(ShouldIncludeLibrary)
+                .OrderBy(l => l.MediaKind)
+                .ThenBy(l => l.Name)
+                .Map(l => new MediaSourceLibraryResponseModel(
+                    l.Id,
+                    l.Name,
+                    l.MediaKind,
+                    l.LastScan,
+                    itemCountsByLibrary.TryGetValue(l.Id, out int count) ? count : 0))
+                .ToList();
+
+            string? address = addressByMediaSourceId.TryGetValue(mediaSource.Id, out string? a) ? a : null;
+
+            result.Add(
+                new MediaSourceResponseModel(
+                    mediaSource.Id,
+                    GetKind(mediaSource),
+                    GetName(mediaSource),
+                    address,
+                    libraryModels));
+        }
+
+        return result
+            .OrderBy(s => s.Kind == "Local" ? 0 : 1)
+            .ThenBy(s => s.Kind)
+            .ThenBy(s => s.Name)
+            .ToList();
+    }
+
+    private static async Task<Dictionary<int, int>> GetItemCountsByLibrary(
+        TvContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        IEnumerable<LibraryItemCount> counts = await dbContext.Connection.QueryAsync<LibraryItemCount>(
+            new CommandDefinition(
+                @"SELECT LP.LibraryId AS LibraryId, COUNT(*) AS Count
+                      FROM MediaItem
+                      INNER JOIN LibraryPath LP on MediaItem.LibraryPathId = LP.Id
+                      GROUP BY LP.LibraryId",
+                cancellationToken: cancellationToken));
+
+        return counts.ToDictionary(c => (int)c.LibraryId, c => (int)c.Count);
+    }
+
+    private static async Task<Dictionary<int, string>> GetConnectionAddresses(
+        TvContext dbContext,
+        CancellationToken cancellationToken)
+    {
+        var addresses = new Dictionary<int, string>();
+
+        foreach (PlexMediaSource plex in await dbContext.PlexMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (PlexConnection connection in Optional(plex.Connections.SingleOrDefault(c => c.IsActive)))
+            {
+                addresses[plex.Id] = connection.Uri;
+            }
+        }
+
+        foreach (JellyfinMediaSource jellyfin in await dbContext.JellyfinMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (JellyfinConnection connection in jellyfin.Connections.HeadOrNone())
+            {
+                addresses[jellyfin.Id] = connection.Address;
+            }
+        }
+
+        foreach (EmbyMediaSource emby in await dbContext.EmbyMediaSources
+                     .AsNoTracking()
+                     .Include(s => s.Connections)
+                     .ToListAsync(cancellationToken))
+        {
+            foreach (EmbyConnection connection in emby.Connections.HeadOrNone())
+            {
+                addresses[emby.Id] = connection.Address;
+            }
+        }
+
+        return addresses;
+    }
+
+    private static bool ShouldIncludeLibrary(Library library) =>
+        library switch
+        {
+            LocalLibrary => library.Paths.Count > 0,
+            PlexLibrary plex => plex.ShouldSyncItems,
+            JellyfinLibrary jellyfin => jellyfin.ShouldSyncItems,
+            EmbyLibrary emby => emby.ShouldSyncItems,
+            _ => false
+        };
+
+    private static string GetKind(MediaSource mediaSource) =>
+        mediaSource switch
+        {
+            PlexMediaSource => "Plex",
+            JellyfinMediaSource => "Jellyfin",
+            EmbyMediaSource => "Emby",
+            _ => "Local"
+        };
+
+    private static string GetName(MediaSource mediaSource) =>
+        mediaSource switch
+        {
+            PlexMediaSource plex => plex.ServerName,
+            JellyfinMediaSource jellyfin => jellyfin.ServerName,
+            EmbyMediaSource emby => emby.ServerName,
+            _ => "Local"
+        };
+
+    private sealed record LibraryItemCount(long LibraryId, long Count);
+}

ErsatzTV.Application/Playouts/Queries/GetPlayoutByIdHandler.cs

@@ -16,6 +16,7 @@ public class GetPlayoutByIdHandler(IDbContextFactory<TvContext> dbContextFactory
             .AsNoTracking()
             .Include(p => p.ProgramSchedule)
             .Include(p => p.Channel)
+            .Include(p => p.BuildStatus)
             .SelectOneAsync(p => p.Id, p => p.Id == request.PlayoutId, cancellationToken)
             .MapT(p => new PlayoutNameViewModel(
                 p.Id,

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemViewModel.cs

@@ -44,6 +44,33 @@ public abstract record ProgramScheduleItemViewModel(
     string PreferredSubtitleLanguageCode,
     ChannelSubtitleMode? SubtitleMode)
 {
+    /// <summary>
+    ///     A rough estimate, in wall-clock time, of how long a single pass of this schedule item will play,
+    ///     derived from the aggregated playout runtimes of the referenced content.
+    ///     <para>
+    ///         Semantics by <see cref="PlayoutMode" />:
+    ///         <list type="bullet">
+    ///             <item><b>One</b> — the average runtime of one item in the referenced collection.</item>
+    ///             <item>
+    ///                 <b>Multiple</b> — the average item runtime multiplied by the configured count
+    ///                 (<see cref="MultipleMode.Count" />), or the whole collection runtime for
+    ///                 <see cref="MultipleMode.CollectionSize" />. An expression-based (non-integer)
+    ///                 count cannot be evaluated here and yields <c>null</c>.
+    ///             </item>
+    ///             <item><b>Flood</b> — always <c>null</c>: a flood item fills the remaining time and is unbounded.</item>
+    ///             <item><b>Duration</b> — the explicit <c>playoutDuration</c> setting on the item.</item>
+    ///         </list>
+    ///     </para>
+    ///     <para>
+    ///         <c>null</c> whenever a bounded estimate cannot be produced — an unbounded mode (Flood),
+    ///         a referenced collection with no items that have a known positive duration, a Multiple mode other
+    ///         than Count/CollectionSize, or a collection type other than <see cref="CollectionType.Collection" />
+    ///         (smart/multi/playlist/search/rerun/show/season/artist references are not aggregated in this pass).
+    ///         Callers should treat a <c>null</c> as "unknown", never as zero.
+    ///     </para>
+    /// </summary>
+    public TimeSpan? DurationEstimate { get; init; }
+
     public string Name => CollectionType switch
     {
         CollectionType.Collection => Collection?.Name,

ErsatzTV.Application/ProgramSchedules/ProgramScheduleItemsWithDurationViewModel.cs

@@ -0,0 +1,18 @@
+namespace ErsatzTV.Application.ProgramSchedules;
+
+/// <summary>
+///     The items of a schedule together with computed runtime estimates. Each item carries its own
+///     <see cref="ProgramScheduleItemViewModel.DurationEstimate" /> (nullable — see that property for
+///     the per-mode semantics), and <see cref="TotalDurationEstimate" /> is the sum of the items that
+///     could be estimated.
+/// </summary>
+/// <param name="Items">The schedule items, each with a nullable <c>DurationEstimate</c>.</param>
+/// <param name="TotalDurationEstimate">
+///     The sum of every non-null per-item estimate, i.e. a rough runtime for a single pass through the
+///     estimable items. <c>null</c> when no item in the schedule could be estimated (for example a
+///     schedule made up entirely of Flood items, or of collection types that are not aggregated).
+///     Because unbounded items contribute nothing, this is a lower bound, never an exact schedule length.
+/// </param>
+public record ProgramScheduleItemsWithDurationViewModel(
+    List<ProgramScheduleItemViewModel> Items,
+    TimeSpan? TotalDurationEstimate);

ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsWithDurations.cs

@@ -0,0 +1,4 @@
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public record GetProgramScheduleItemsWithDurations(int Id)
+    : IRequest<ProgramScheduleItemsWithDurationViewModel>;

ErsatzTV.Application/ProgramSchedules/Queries/GetProgramScheduleItemsWithDurationsHandler.cs

@@ -0,0 +1,70 @@
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Extensions;
+using ErsatzTV.Core.Interfaces.Repositories;
+using static ErsatzTV.Application.ProgramSchedules.ScheduleItemDurationEstimator;
+
+namespace ErsatzTV.Application.ProgramSchedules;
+
+public class GetProgramScheduleItemsWithDurationsHandler(
+    IMediator mediator,
+    IMediaCollectionRepository mediaCollectionRepository)
+    : IRequestHandler<GetProgramScheduleItemsWithDurations, ProgramScheduleItemsWithDurationViewModel>
+{
+    public async Task<ProgramScheduleItemsWithDurationViewModel> Handle(
+        GetProgramScheduleItemsWithDurations request,
+        CancellationToken cancellationToken)
+    {
+        List<ProgramScheduleItemViewModel> items =
+            await mediator.Send(new GetProgramScheduleItems(request.Id), cancellationToken);
+
+        Dictionary<int, CollectionDuration> durationsByCollectionId =
+            await AggregateReferencedCollections(items);
+
+        var itemsWithEstimates = items
+            .Map(item => item with { DurationEstimate = Estimate(item, durationsByCollectionId) })
+            .ToList();
+
+        List<TimeSpan> estimates = itemsWithEstimates
+            .Map(item => Optional(item.DurationEstimate))
+            .Somes()
+            .ToList();
+
+        TimeSpan? total = estimates.Count > 0
+            ? TimeSpan.FromTicks(estimates.Sum(estimate => estimate.Ticks))
+            : null;
+
+        return new ProgramScheduleItemsWithDurationViewModel(itemsWithEstimates, total);
+    }
+
+    // Aggregate MediaVersion.Duration once per distinct referenced collection (not per item). Only plain
+    // collections are resolved here; other reference types are estimated as null (see DurationEstimate docs).
+    private async Task<Dictionary<int, CollectionDuration>> AggregateReferencedCollections(
+        IReadOnlyList<ProgramScheduleItemViewModel> items)
+    {
+        List<int> collectionIds = items
+            .Filter(item => item.CollectionType is CollectionType.Collection && item.Collection is not null)
+            .Filter(item => item.PlayoutMode is PlayoutMode.One or PlayoutMode.Multiple)
+            .Map(item => item.Collection.Id)
+            .Distinct()
+            .ToList();
+
+        var result = new Dictionary<int, CollectionDuration>();
+        foreach (int collectionId in collectionIds)
+        {
+            List<MediaItem> mediaItems = await mediaCollectionRepository.GetItems(collectionId);
+
+            List<TimeSpan> durations = mediaItems
+                .Map(mediaItem => mediaItem.GetDurationForPlayout())
+                .Filter(duration => duration > TimeSpan.Zero)
+                .ToList();
+
+            if (durations.Count > 0)
+            {
+                var total = TimeSpan.FromTicks(durations.Sum(duration => duration.Ticks));
+                result[collectionId] = new CollectionDuration(total, durations.Count);
+            }
+        }
+
+        return result;
+    }
+}

ErsatzTV.Application/ProgramSchedules/ScheduleItemDurationEstimator.cs

@@ -0,0 +1,73 @@
+using System.Globalization;
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Application.ProgramSchedules;
+
+/// <summary>
+///     Pure computation of per-item runtime estimates from pre-aggregated collection durations.
+///     Kept separate from the query handler so the (non-trivial) per-mode math can be unit-tested
+///     without a database. See <see cref="ProgramScheduleItemViewModel.DurationEstimate" /> for the
+///     documented semantics this implements.
+/// </summary>
+internal static class ScheduleItemDurationEstimator
+{
+    /// <summary>
+    ///     Aggregate runtime of a single referenced collection: the total runtime of every item with a
+    ///     known non-zero duration, and how many such items there are.
+    /// </summary>
+    public sealed record CollectionDuration(TimeSpan Total, int ItemCount)
+    {
+        public TimeSpan? Average => ItemCount > 0 ? Total / ItemCount : null;
+    }
+
+    /// <summary>
+    ///     Estimate the runtime of one pass of <paramref name="item" />, or <c>null</c> when no bounded
+    ///     estimate is possible. <paramref name="durationsByCollectionId" /> holds aggregates only for the
+    ///     plain collections that were resolved; a missing entry yields <c>null</c>.
+    /// </summary>
+    public static TimeSpan? Estimate(
+        ProgramScheduleItemViewModel item,
+        IReadOnlyDictionary<int, CollectionDuration> durationsByCollectionId)
+    {
+        if (item is ProgramScheduleItemDurationViewModel durationItem)
+        {
+            return durationItem.PlayoutDuration;
+        }
+
+        // only plain collections are aggregated in this pass
+        if (item.CollectionType is not CollectionType.Collection || item.Collection is null)
+        {
+            return null;
+        }
+
+        if (!durationsByCollectionId.TryGetValue(item.Collection.Id, out CollectionDuration duration))
+        {
+            return null;
+        }
+
+        return item switch
+        {
+            // one item per pass -> the average item runtime
+            ProgramScheduleItemOneViewModel => duration.Average,
+
+            // a fixed count of items, or the whole collection once
+            ProgramScheduleItemMultipleViewModel multiple => EstimateMultiple(multiple, duration),
+
+            // Flood is an unbounded fill; Duration is handled above from its explicit playoutDuration.
+            _ => null
+        };
+    }
+
+    private static TimeSpan? EstimateMultiple(
+        ProgramScheduleItemMultipleViewModel multiple,
+        CollectionDuration duration) =>
+        multiple.MultipleMode switch
+        {
+            MultipleMode.Count when
+                int.TryParse(multiple.Count, NumberStyles.Integer, CultureInfo.InvariantCulture, out int count)
+                && count > 0
+                && duration.Average is { } average => average * count,
+            MultipleMode.CollectionSize => duration.Total,
+            _ => null
+        };
+}

ErsatzTV.Application/Watermarks/Mapper.cs

@@ -1,10 +1,14 @@
 using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core.Api.Watermarks;
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Application.Watermarks;
 
 internal static class Mapper
 {
+    internal static WatermarkResponseModel ProjectToResponseModel(ChannelWatermark watermark) =>
+        new(watermark.Id, watermark.Name);
+
     public static WatermarkViewModel ProjectToViewModel(ChannelWatermark watermark) =>
         new(
             watermark.Id,

ErsatzTV.Application/Watermarks/Queries/GetAllWatermarksForApi.cs

@@ -0,0 +1,5 @@
+using ErsatzTV.Core.Api.Watermarks;
+
+namespace ErsatzTV.Application.Watermarks;
+
+public record GetAllWatermarksForApi : IRequest<List<WatermarkResponseModel>>;

ErsatzTV.Application/Watermarks/Queries/GetAllWatermarksForApiHandler.cs

@@ -0,0 +1,22 @@
+using ErsatzTV.Core.Api.Watermarks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using Microsoft.EntityFrameworkCore;
+using static ErsatzTV.Application.Watermarks.Mapper;
+
+namespace ErsatzTV.Application.Watermarks;
+
+public class GetAllWatermarksForApiHandler(IDbContextFactory<TvContext> dbContextFactory)
+    : IRequestHandler<GetAllWatermarksForApi, List<WatermarkResponseModel>>
+{
+    public async Task<List<WatermarkResponseModel>> Handle(
+        GetAllWatermarksForApi request,
+        CancellationToken cancellationToken)
+    {
+        await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
+        List<ChannelWatermark> watermarks = await dbContext.ChannelWatermarks
+            .AsNoTracking()
+            .ToListAsync(cancellationToken);
+        return watermarks.Map(ProjectToResponseModel).ToList();
+    }
+}

ErsatzTV.Core/Api/Artwork/ArtworkUploadResponseModel.cs

@@ -0,0 +1,10 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Artwork;
+
+/// <summary>
+///     Result of uploading channel logo / watermark artwork via the REST API.
+///     <see cref="Path" /> is directly consumable as the <c>Path</c> of an
+///     <c>ArtworkContentTypeModel</c> (e.g. <c>CreateChannel.Logo</c> / channel update),
+///     and <see cref="ContentType" /> carries the stored MIME type.
+/// </summary>
+public record ArtworkUploadResponseModel(string Path, string ContentType);

ErsatzTV.Core/Api/Channels/ChannelGuideResponseModel.cs

@@ -0,0 +1,25 @@
+#nullable enable
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Core.Api.Channels;
+
+/// <summary>A single guide programme for the JSON EPG grid.</summary>
+public record ChannelGuideProgrammeResponseModel(
+    DateTimeOffset Start,
+    DateTimeOffset Stop,
+    string Title,
+    string? SubTitle,
+    string? Category,
+    FillerKind FillerKind);
+
+/// <summary>One channel's guide programmes for the requested window.</summary>
+public record ChannelGuideChannelResponseModel(
+    string Number,
+    string Name,
+    List<ChannelGuideProgrammeResponseModel> Programmes);
+
+/// <summary>The JSON channel-guide response: the resolved window plus per-channel programme arrays.</summary>
+public record ChannelGuideResponseModel(
+    DateTimeOffset Start,
+    DateTimeOffset End,
+    List<ChannelGuideChannelResponseModel> Channels);

ErsatzTV.Core/Api/Filler/FillerPresetResponseModel.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Core.Api.Filler;
+
+public record FillerPresetResponseModel(int Id, string Name);

ErsatzTV.Core/Api/Graphics/GraphicsElementResponseModel.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Core.Api.Graphics;
+
+public record GraphicsElementResponseModel(int Id, string Name);

ErsatzTV.Core/Api/Health/HealthCheckResponseModel.cs

@@ -0,0 +1,8 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.Health;
+
+public record HealthCheckResponseModel(
+    string Title,
+    string Status,
+    string Detail,
+    string? Link);

ErsatzTV.Core/Api/Libraries/LibraryScanStatusResponseModel.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Core.Api.Libraries;
+
+public record LibraryScanStatusResponseModel(int LibraryId, decimal Percent);

ErsatzTV.Core/Api/MediaSources/MediaSourceLibraryResponseModel.cs

@@ -0,0 +1,11 @@
+#nullable enable
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Core.Api.MediaSources;
+
+public record MediaSourceLibraryResponseModel(
+    int Id,
+    string Name,
+    LibraryMediaKind MediaKind,
+    DateTime? LastScan,
+    int ItemCount);

ErsatzTV.Core/Api/MediaSources/MediaSourceResponseModel.cs

@@ -0,0 +1,9 @@
+#nullable enable
+namespace ErsatzTV.Core.Api.MediaSources;
+
+public record MediaSourceResponseModel(
+    int Id,
+    string Kind,
+    string Name,
+    string? ConnectionAddress,
+    List<MediaSourceLibraryResponseModel> Libraries);

ErsatzTV.Core/Api/Playouts/PagedPlayoutItemsResponseModel.cs

@@ -0,0 +1,5 @@
+namespace ErsatzTV.Core.Api.Playouts;
+
+public record PagedPlayoutItemsResponseModel(
+    int TotalCount,
+    List<PlayoutItemResponseModel> Page);

ErsatzTV.Core/Api/Playouts/PagedPlayoutsResponseModel.cs

@@ -0,0 +1,5 @@
+namespace ErsatzTV.Core.Api.Playouts;
+
+public record PagedPlayoutsResponseModel(
+    int TotalCount,
+    List<PlayoutListItemResponseModel> Page);

ErsatzTV.Core/Api/Playouts/PlayoutBuildStatusResponseModel.cs

@@ -0,0 +1,6 @@
+namespace ErsatzTV.Core.Api.Playouts;
+
+public record PlayoutBuildStatusResponseModel(
+    DateTimeOffset LastBuild,
+    bool Success,
+    string Message);

ErsatzTV.Core/Api/Playouts/PlayoutItemResponseModel.cs

@@ -0,0 +1,10 @@
+using ErsatzTV.Core.Domain.Filler;
+
+namespace ErsatzTV.Core.Api.Playouts;
+
+public record PlayoutItemResponseModel(
+    string Title,
+    DateTimeOffset Start,
+    DateTimeOffset Finish,
+    string Duration,
+    FillerKind? FillerKind);

ErsatzTV.Core/Api/Playouts/PlayoutListItemResponseModel.cs

@@ -0,0 +1,13 @@
+#nullable enable
+using ErsatzTV.Core.Domain;
+
+namespace ErsatzTV.Core.Api.Playouts;
+
+public record PlayoutListItemResponseModel(
+    int Id,
+    string ChannelNumber,
+    string ChannelName,
+    PlayoutScheduleKind ScheduleKind,
+    string ScheduleName,
+    TimeSpan? DailyRebuildTime,
+    PlayoutBuildStatusResponseModel? BuildStatus);

ErsatzTV.Core/Api/Playouts/PlayoutResponseModel.cs

@@ -1,3 +1,4 @@
+#nullable enable
 using ErsatzTV.Core.Domain;
 
 namespace ErsatzTV.Core.Api.Playouts;
@@ -9,8 +10,9 @@ public record PlayoutResponseModel(
     string ChannelNumber,
     ChannelPlayoutMode PlayoutMode,
     string ScheduleName,
-    string ScheduleFile,
-    TimeSpan? DailyRebuildTime)
+    string? ScheduleFile,
+    TimeSpan? DailyRebuildTime,
+    PlayoutBuildStatusResponseModel? BuildStatus)
 {
     public static PlayoutResponseModel From(
         int id,
@@ -19,8 +21,9 @@ public record PlayoutResponseModel(
         string channelNumber,
         ChannelPlayoutMode playoutMode,
         string scheduleName,
-        string scheduleFile,
-        TimeSpan? dailyRebuildTime) =>
+        string? scheduleFile,
+        TimeSpan? dailyRebuildTime,
+        PlayoutBuildStatusResponseModel? buildStatus) =>
         new(
             id,
             scheduleKind,
@@ -29,5 +32,6 @@ public record PlayoutResponseModel(
             playoutMode,
             scheduleName,
             scheduleFile,
-            dailyRebuildTime);
+            dailyRebuildTime,
+            buildStatus);
 }

ErsatzTV.Core/Api/Watermarks/WatermarkResponseModel.cs

@@ -0,0 +1,3 @@
+namespace ErsatzTV.Core.Api.Watermarks;
+
+public record WatermarkResponseModel(int Id, string Name);

ErsatzTV.Core/Interfaces/Metadata/IScannerProxyService.cs

@@ -1,3 +1,5 @@
+using ErsatzTV.Core.Metadata;
+
 namespace ErsatzTV.Core.Interfaces.Metadata;
 
 public interface IScannerProxyService
@@ -7,4 +9,5 @@ public interface IScannerProxyService
     Task Progress(Guid scanId, decimal percentComplete);
     bool IsActive(Guid scanId);
     Option<decimal> GetProgress(int libraryId);
+    IReadOnlyList<LibraryScanProgress> GetActiveScans();
 }

ErsatzTV.Core/Metadata/ScannerProxyService.cs

@@ -49,4 +49,7 @@ public class ScannerProxyService(IMediator mediator) : IScannerProxyService
     public Option<decimal> GetProgress(int libraryId) => _activeLibraries.TryGetValue(libraryId, out decimal progress)
         ? progress
         : Option<decimal>.None;
+
+    public IReadOnlyList<LibraryScanProgress> GetActiveScans() =>
+        _activeLibraries.Select(kvp => new LibraryScanProgress(kvp.Key, kvp.Value)).ToList();
 }

ErsatzTV.Infrastructure/Extensions/PlayoutGuideQueryableExtensions.cs

@@ -0,0 +1,98 @@
+using ErsatzTV.Core.Domain;
+using Microsoft.EntityFrameworkCore;
+
+namespace ErsatzTV.Infrastructure.Extensions;
+
+public static class PlayoutGuideQueryableExtensions
+{
+    /// <summary>
+    ///     Eager-loads the full playout-item metadata graph needed to render guide programme
+    ///     titles/subtitles/categories/artwork. Shared by the XMLTV cache builder and the JSON guide
+    ///     query so both surfaces see identical data. Callers should apply <c>AsSplitQuery()</c>.
+    /// </summary>
+    public static IQueryable<Playout> IncludeGuideMetadata(this IQueryable<Playout> playouts) =>
+        playouts
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).EpisodeMetadata)
+            .ThenInclude(em => em.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Episode).Season)
+            .ThenInclude(s => s.Show)
+            .ThenInclude(s => s.ShowMetadata)
+            .ThenInclude(sm => sm.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Movie).MovieMetadata)
+            .ThenInclude(mm => mm.Guids)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mm => mm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Studios)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Directors)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).MusicVideoMetadata)
+            .ThenInclude(mvm => mvm.Artists)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as MusicVideo).Artist)
+            .ThenInclude(a => a.ArtistMetadata)
+            .ThenInclude(am => am.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as OtherVideo).OtherVideoMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as RemoteStream).RemoteStreamMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(vm => vm.Artwork)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(sm => sm.Genres)
+            .Include(p => p.Items)
+            .ThenInclude(i => i.MediaItem)
+            .ThenInclude(i => (i as Song).SongMetadata)
+            .ThenInclude(sm => sm.Studios);
+}

ErsatzTV.Tests/Application/Artworks/UploadArtworkHandlerTests.cs

@@ -0,0 +1,87 @@
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Images;
+using LanguageExt;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Tests.Application.Artworks;
+
+[TestFixture]
+public class UploadArtworkHandlerTests
+{
+    private IImageCache _imageCache = null!;
+    private UploadArtworkHandler _handler = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _imageCache = Substitute.For<IImageCache>();
+        _handler = new UploadArtworkHandler(_imageCache);
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Logo_Path_With_Iptv_Logos_Prefix()
+    {
+        _imageCache.SaveArtworkToCache(Arg.Any<Stream>(), ArtworkKind.Logo)
+            .Returns(Right<BaseError, string>("abc123.png"));
+
+        using var stream = new MemoryStream();
+        Either<BaseError, ArtworkUploadResponseModel> result =
+            await _handler.Handle(new UploadArtwork(stream, "image/png", ArtworkKind.Logo), CancellationToken.None);
+
+        ArtworkUploadResponseModel response = RightOf(result);
+        response.Path.ShouldBe("iptv/logos/abc123.png");
+        response.ContentType.ShouldBe("image/png");
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Bare_File_Name_For_Watermark()
+    {
+        _imageCache.SaveArtworkToCache(Arg.Any<Stream>(), ArtworkKind.Watermark)
+            .Returns(Right<BaseError, string>("def456.webp"));
+
+        using var stream = new MemoryStream();
+        Either<BaseError, ArtworkUploadResponseModel> result = await _handler.Handle(
+            new UploadArtwork(stream, "image/webp", ArtworkKind.Watermark),
+            CancellationToken.None);
+
+        RightOf(result).Path.ShouldBe("def456.webp");
+    }
+
+    [Test]
+    public async Task Handle_Should_Reject_Unsupported_Content_Type()
+    {
+        using var stream = new MemoryStream();
+        Either<BaseError, ArtworkUploadResponseModel> result = await _handler.Handle(
+            new UploadArtwork(stream, "image/bmp", ArtworkKind.Logo),
+            CancellationToken.None);
+
+        LeftOf(result).Value.ShouldContain("Unsupported image content type");
+        await _imageCache.DidNotReceive().SaveArtworkToCache(Arg.Any<Stream>(), Arg.Any<ArtworkKind>());
+    }
+
+    [Test]
+    public async Task Handle_Should_Propagate_Cache_Save_Failure()
+    {
+        _imageCache.SaveArtworkToCache(Arg.Any<Stream>(), ArtworkKind.Logo)
+            .Returns(Left<BaseError, string>(BaseError.New("disk full")));
+
+        using var stream = new MemoryStream();
+        Either<BaseError, ArtworkUploadResponseModel> result = await _handler.Handle(
+            new UploadArtwork(stream, "image/png", ArtworkKind.Logo),
+            CancellationToken.None);
+
+        LeftOf(result).Value.ShouldBe("disk full");
+    }
+
+    private static TR RightOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Right: v => v, Left: e => throw new AssertionException($"Expected Right, got Left: {e.Value}"));
+
+    private static BaseError LeftOf<TR>(Either<BaseError, TR> either) =>
+        either.Match(Right: _ => throw new AssertionException("Expected Left, got Right"), Left: e => e);
+}

ErsatzTV.Tests/Application/Channels/GetChannelGuideDataHandlerTests.cs

@@ -0,0 +1,316 @@
+using ErsatzTV.Application.Channels;
+using ErsatzTV.Application.Configuration;
+using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using LanguageExt;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using DomainChannel = ErsatzTV.Core.Domain.Channel;
+
+namespace ErsatzTV.Tests.Application.Channels;
+
+[TestFixture]
+public class GetChannelGuideDataHandlerTests
+{
+    private static readonly DateTime BaseTime = new(2026, 1, 1, 8, 0, 0, DateTimeKind.Utc);
+
+    private InMemoryTvContext _db = null!;
+    private IConfigElementRepository _config = null!;
+
+    [SetUp]
+    public async Task SetUp()
+    {
+        _db = await InMemoryTvContext.CreateAsync();
+        _config = Substitute.For<IConfigElementRepository>();
+
+        // ConfigElementKey has reference equality and each static accessor returns a fresh instance, so we
+        // match by the generic value type (GetValue<T>) with Arg.Any key. Pin the time zone to UTC so
+        // projected times are deterministic regardless of the machine/CI time zone, and split block time
+        // evenly. XmltvDaysToBuild is left unconfigured (falls back to 2) except in the default-window test.
+        _config.GetValue<XmltvTimeZone>(Arg.Any<ConfigElementKey>(), Arg.Any<CancellationToken>())
+            .Returns(Option<XmltvTimeZone>.Some(XmltvTimeZone.Utc));
+        _config.GetValue<XmltvBlockBehavior>(Arg.Any<ConfigElementKey>(), Arg.Any<CancellationToken>())
+            .Returns(Option<XmltvBlockBehavior>.Some(XmltvBlockBehavior.SplitTimeEvenly));
+    }
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    private GetChannelGuideDataHandler MakeHandler() => new(_db.Factory, _config);
+
+    [Test]
+    public async Task Handle_Should_Only_Include_Visible_Channels()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel visible = NewChannel("2", "Visible", showInEpg: true);
+            DomainChannel hidden = NewChannel("3", "Hidden", showInEpg: false);
+            visible.Playouts = [MakeFloodPlayout(visible, (BaseTime, BaseTime.AddHours(1), 1, "Visible Show"))];
+            hidden.Playouts = [MakeFloodPlayout(hidden, (BaseTime, BaseTime.AddHours(1), 1, "Hidden Show"))];
+            context.Channels.AddRange(visible, hidden);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        result.Channels.Select(c => c.Number).ShouldBe(["2"]);
+    }
+
+    [Test]
+    public async Task Handle_Should_Order_Channels_By_Decimal_Number()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            context.Channels.Add(NewChannel("10", "Ten", showInEpg: true));
+            context.Channels.Add(NewChannel("2", "Two", showInEpg: true));
+            context.Channels.Add(NewChannel("5.1", "FiveOne", showInEpg: true));
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        // decimal order: 2 < 5.1 < 10 (string order would put "10" first)
+        result.Channels.Select(c => c.Number).ShouldBe(["2", "5.1", "10"]);
+    }
+
+    [Test]
+    public async Task Handle_Should_Filter_Programmes_To_Requested_Window()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel channel = NewChannel("2", "Two", showInEpg: true);
+            channel.Playouts =
+            [
+                MakeFloodPlayout(
+                    channel,
+                    (BaseTime, BaseTime.AddHours(1), 1, "Before Window"),
+                    (BaseTime.AddHours(10), BaseTime.AddHours(11), 2, "In Window"))
+            ];
+            context.Channels.Add(channel);
+            await context.SaveChangesAsync();
+        }
+
+        // window starts after the first programme has finished
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime.AddHours(5), BaseTime.AddHours(20)),
+            CancellationToken.None);
+
+        List<ChannelGuideProgrammeResponseModel> programmes = result.Channels.Single().Programmes;
+        programmes.Select(p => p.Title).ShouldBe(["In Window"]);
+    }
+
+    [Test]
+    public async Task Handle_Should_Passthrough_Custom_Title_And_Null_SubTitle()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel channel = NewChannel("2", "Two", showInEpg: true);
+            PlayoutItem item = MakeItem(BaseTime, BaseTime.AddHours(1), guideGroup: 1, movieTitle: "Ignored");
+            item.CustomTitle = "Custom Title";
+            channel.Playouts = [MakePlayout(channel, PlayoutScheduleKind.Classic, [item])];
+            context.Channels.Add(channel);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        ChannelGuideProgrammeResponseModel programme = result.Channels.Single().Programmes.Single();
+        programme.Title.ShouldBe("Custom Title");
+        programme.SubTitle.ShouldBeNull();
+        programme.Category.ShouldBe("Movie");
+    }
+
+    [Test]
+    public async Task Handle_Should_Merge_Leading_PreRoll_Filler_Into_Following_Programme()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel channel = NewChannel("2", "Two", showInEpg: true);
+            PlayoutItem preRoll = MakeItem(BaseTime, BaseTime.AddMinutes(5), guideGroup: 1, movieTitle: "Bumper");
+            preRoll.FillerKind = FillerKind.PreRoll;
+            PlayoutItem content = MakeItem(BaseTime.AddMinutes(5), BaseTime.AddHours(1), guideGroup: 1, movieTitle: "Feature");
+            channel.Playouts = [MakePlayout(channel, PlayoutScheduleKind.Classic, [preRoll, content])];
+            context.Channels.Add(channel);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        ChannelGuideProgrammeResponseModel programme = result.Channels.Single().Programmes.Single();
+        // filler is merged: the programme starts at the pre-roll start but displays the feature metadata
+        programme.Title.ShouldBe("Feature");
+        programme.Start.ShouldBe(new DateTimeOffset(BaseTime, TimeSpan.Zero));
+        programme.Stop.ShouldBe(new DateTimeOffset(BaseTime.AddHours(1), TimeSpan.Zero));
+        programme.FillerKind.ShouldBe(FillerKind.None);
+    }
+
+    [Test]
+    public async Task Handle_Should_Split_Block_Window_Evenly_Across_Content_Items()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel channel = NewChannel("2", "Two", showInEpg: true);
+            PlayoutItem one = MakeItem(BaseTime, BaseTime.AddMinutes(20), guideGroup: 7, movieTitle: "One");
+            PlayoutItem two = MakeItem(BaseTime.AddMinutes(20), BaseTime.AddMinutes(40), guideGroup: 7, movieTitle: "Two");
+            foreach (PlayoutItem item in new[] { one, two })
+            {
+                item.GuideStart = BaseTime;
+                item.GuideFinish = BaseTime.AddHours(1);
+            }
+
+            channel.Playouts = [MakePlayout(channel, PlayoutScheduleKind.Block, [one, two])];
+            context.Channels.Add(channel);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        List<ChannelGuideProgrammeResponseModel> programmes = result.Channels.Single().Programmes;
+        programmes.Count.ShouldBe(2);
+        // 1-hour guide window split evenly across the 2 content items -> 30 minutes each
+        programmes[0].Start.ShouldBe(new DateTimeOffset(BaseTime, TimeSpan.Zero));
+        programmes[0].Stop.ShouldBe(new DateTimeOffset(BaseTime.AddMinutes(30), TimeSpan.Zero));
+        programmes[1].Start.ShouldBe(new DateTimeOffset(BaseTime.AddMinutes(30), TimeSpan.Zero));
+        programmes[1].Stop.ShouldBe(new DateTimeOffset(BaseTime.AddHours(1), TimeSpan.Zero));
+    }
+
+    [Test]
+    public async Task Handle_Should_Default_Start_To_Now_And_End_To_DaysToBuild()
+    {
+        _config.GetValue<int>(Arg.Any<ConfigElementKey>(), Arg.Any<CancellationToken>())
+            .Returns(Option<int>.Some(3));
+
+        DateTimeOffset before = DateTimeOffset.UtcNow;
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(null, null),
+            CancellationToken.None);
+        DateTimeOffset after = DateTimeOffset.UtcNow;
+
+        result.Start.ShouldBeInRange(before, after);
+        (result.End - result.Start).ShouldBe(TimeSpan.FromDays(3));
+    }
+
+    [Test]
+    public async Task Handle_Should_Shift_Mirror_Channel_Programmes_By_PlayoutOffset_Without_Mutating_Source_Items()
+    {
+        PlayoutItem sourceItem = MakeItem(BaseTime, BaseTime.AddHours(1), guideGroup: 1, movieTitle: "Live Show");
+        var playoutOffset = TimeSpan.FromHours(3);
+
+        await using (TvContext context = _db.CreateContext())
+        {
+            DomainChannel source = NewChannel("1", "Source", showInEpg: false);
+            source.Playouts = [MakePlayout(source, PlayoutScheduleKind.Classic, [sourceItem])];
+
+            DomainChannel mirror = NewChannel("2", "Mirror", showInEpg: true);
+            mirror.PlayoutSource = ChannelPlayoutSource.Mirror;
+            mirror.MirrorSourceChannel = source;
+            mirror.PlayoutOffset = playoutOffset;
+
+            context.Channels.AddRange(source, mirror);
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        ChannelGuideProgrammeResponseModel programme = result.Channels.Single(c => c.Number == "2").Programmes.Single();
+        programme.Title.ShouldBe("Live Show");
+        programme.Start.ShouldBe(new DateTimeOffset(BaseTime.Add(playoutOffset), TimeSpan.Zero));
+        programme.Stop.ShouldBe(new DateTimeOffset(BaseTime.AddHours(1).Add(playoutOffset), TimeSpan.Zero));
+
+        // the WithPlayoutOffset copy fix: applying the mirror offset must not mutate the source playout's
+        // own (shared, AsNoTracking) PlayoutItem entities in place.
+        sourceItem.Start.ShouldBe(BaseTime);
+        sourceItem.Finish.ShouldBe(BaseTime.AddHours(1));
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Empty_Programmes_For_Channel_Without_Playout()
+    {
+        await using (TvContext context = _db.CreateContext())
+        {
+            context.Channels.Add(NewChannel("2", "Two", showInEpg: true));
+            await context.SaveChangesAsync();
+        }
+
+        ChannelGuideResponseModel result = await MakeHandler().Handle(
+            new GetChannelGuideData(BaseTime, BaseTime.AddDays(1)),
+            CancellationToken.None);
+
+        result.Channels.Single().Programmes.ShouldBeEmpty();
+    }
+
+    // --- seeding helpers ---
+
+    private static Playout MakeFloodPlayout(
+        DomainChannel channel,
+        params (DateTime Start, DateTime Finish, int GuideGroup, string Title)[] items) =>
+        MakePlayout(
+            channel,
+            PlayoutScheduleKind.Classic,
+            items.Select(i => MakeItem(i.Start, i.Finish, i.GuideGroup, i.Title)).ToList());
+
+    private static Playout MakePlayout(
+        DomainChannel channel,
+        PlayoutScheduleKind scheduleKind,
+        List<PlayoutItem> items) =>
+        new()
+        {
+            Channel = channel,
+            ScheduleKind = scheduleKind,
+            ScheduleFile = string.Empty,
+            Items = items
+        };
+
+    private static PlayoutItem MakeItem(
+        DateTime start,
+        DateTime finish,
+        int guideGroup,
+        string movieTitle) =>
+        new()
+        {
+            Start = start,
+            Finish = finish,
+            GuideGroup = guideGroup,
+            FillerKind = FillerKind.None,
+            MediaItem = new Movie
+            {
+                MovieMetadata = [new MovieMetadata { Title = movieTitle }],
+                MediaVersions = []
+            }
+        };
+
+    private static DomainChannel NewChannel(string number, string name, bool showInEpg) =>
+        new(Guid.NewGuid())
+        {
+            Number = number,
+            Name = name,
+            Group = "ErsatzTV",
+            Categories = string.Empty,
+            StreamSelector = string.Empty,
+            PreferredAudioLanguageCode = string.Empty,
+            PreferredAudioTitle = string.Empty,
+            PreferredSubtitleLanguageCode = string.Empty,
+            MusicVideoCreditsTemplate = string.Empty,
+            PlayoutSource = ChannelPlayoutSource.Generated,
+            PlayoutMode = ChannelPlayoutMode.Continuous,
+            ShowInEpg = showInEpg,
+            Playouts = []
+        };
+}

ErsatzTV.Tests/Application/Filler/FillerPresetHandlerTests.cs

@@ -0,0 +1,63 @@
+using ErsatzTV.Application.Filler;
+using ErsatzTV.Core.Api.Filler;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Filler;
+
+[TestFixture]
+public class FillerPresetHandlerTests
+{
+    private InMemoryTvContext _db = null!;
+
+    [SetUp]
+    public async Task SetUp() => _db = await InMemoryTvContext.CreateAsync();
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task GetAllFillerPresetsForApi_Should_Return_All_Presets()
+    {
+        await SeedPreset(1, "Intro");
+        await SeedPreset(2, "Outro");
+
+        var handler = new GetAllFillerPresetsForApiHandler(_db.Factory);
+
+        List<FillerPresetResponseModel> result =
+            await handler.Handle(new GetAllFillerPresetsForApi(), CancellationToken.None);
+
+        result.Count.ShouldBe(2);
+        result.ShouldContain(new FillerPresetResponseModel(1, "Intro"));
+        result.ShouldContain(new FillerPresetResponseModel(2, "Outro"));
+    }
+
+    [Test]
+    public async Task GetAllFillerPresetsForApi_Should_Return_Empty_List_When_None_Exist()
+    {
+        var handler = new GetAllFillerPresetsForApiHandler(_db.Factory);
+
+        List<FillerPresetResponseModel> result =
+            await handler.Handle(new GetAllFillerPresetsForApi(), CancellationToken.None);
+
+        result.ShouldBeEmpty();
+    }
+
+    private async Task SeedPreset(int id, string name)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.FillerPresets.Add(new FillerPreset
+        {
+            Id = id,
+            Name = name,
+            FillerKind = FillerKind.PreRoll,
+            FillerMode = FillerMode.Duration,
+            CollectionType = CollectionType.Collection
+        });
+        await context.SaveChangesAsync();
+    }
+}

ErsatzTV.Tests/Application/Graphics/GraphicsElementHandlerTests.cs

@@ -0,0 +1,77 @@
+using ErsatzTV.Application.Graphics;
+using ErsatzTV.Core.Api.Graphics;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Graphics;
+
+[TestFixture]
+public class GraphicsElementHandlerTests
+{
+    private InMemoryTvContext _db = null!;
+
+    [SetUp]
+    public async Task SetUp() => _db = await InMemoryTvContext.CreateAsync();
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task GetAllGraphicsElementsForApi_Should_Return_All_Elements()
+    {
+        await SeedElement(1, "watermark.png", GraphicsElementKind.Image, "Custom Watermark");
+        await SeedElement(2, "clock.png", GraphicsElementKind.Image, string.Empty);
+
+        var handler = new GetAllGraphicsElementsForApiHandler(_db.Factory);
+
+        List<GraphicsElementResponseModel> result =
+            await handler.Handle(new GetAllGraphicsElementsForApi(), CancellationToken.None);
+
+        result.Count.ShouldBe(2);
+        result.Select(e => e.Id).ShouldBe([1, 2]);
+    }
+
+    [Test]
+    public async Task GetAllGraphicsElementsForApi_Should_Order_Named_Elements_Before_Unnamed()
+    {
+        // unnamed element's projected Name equals its FileName -> should sort after named elements
+        await SeedElement(1, "aaa.png", GraphicsElementKind.Image, string.Empty);
+        await SeedElement(2, "zzz.png", GraphicsElementKind.Image, "A Custom Name");
+
+        var handler = new GetAllGraphicsElementsForApiHandler(_db.Factory);
+
+        List<GraphicsElementResponseModel> result =
+            await handler.Handle(new GetAllGraphicsElementsForApi(), CancellationToken.None);
+
+        result.Count.ShouldBe(2);
+        result[0].Id.ShouldBe(2);
+        result[1].Id.ShouldBe(1);
+    }
+
+    [Test]
+    public async Task GetAllGraphicsElementsForApi_Should_Return_Empty_List_When_None_Exist()
+    {
+        var handler = new GetAllGraphicsElementsForApiHandler(_db.Factory);
+
+        List<GraphicsElementResponseModel> result =
+            await handler.Handle(new GetAllGraphicsElementsForApi(), CancellationToken.None);
+
+        result.ShouldBeEmpty();
+    }
+
+    private async Task SeedElement(int id, string path, GraphicsElementKind kind, string name)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.GraphicsElements.Add(new GraphicsElement
+        {
+            Id = id,
+            Path = path,
+            Name = name,
+            Kind = kind
+        });
+        await context.SaveChangesAsync();
+    }
+}

ErsatzTV.Tests/Application/Health/GetAllHealthCheckResultsForApiHandlerTests.cs

@@ -0,0 +1,111 @@
+using ErsatzTV.Application.Health;
+using ErsatzTV.Core.Api.Health;
+using ErsatzTV.Core.Health;
+using LanguageExt;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Health;
+
+[TestFixture]
+public class GetAllHealthCheckResultsForApiHandlerTests
+{
+    private IHealthCheckService _healthCheckService = null!;
+    private GetAllHealthCheckResultsForApiHandler _handler = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _healthCheckService = Substitute.For<IHealthCheckService>();
+        _handler = new GetAllHealthCheckResultsForApiHandler(_healthCheckService);
+    }
+
+    [Test]
+    public async Task Should_Map_Status_Codes_To_Lowercase_Strings()
+    {
+        var results = new List<HealthCheckResult>
+        {
+            new("Pass Check", HealthCheckStatus.Pass, "all good", "ok", Option<HealthCheckLink>.None),
+            new("Fail Check", HealthCheckStatus.Fail, "broken", "bad", Option<HealthCheckLink>.None),
+            new("Warn Check", HealthCheckStatus.Warning, "watch out", "warn", Option<HealthCheckLink>.None),
+            new("Info Check", HealthCheckStatus.Info, "fyi", "info", Option<HealthCheckLink>.None)
+        };
+
+        _healthCheckService.PerformHealthChecks(Arg.Any<CancellationToken>()).Returns(results);
+
+        List<HealthCheckResponseModel> response =
+            await _handler.Handle(new GetAllHealthCheckResultsForApi(), CancellationToken.None);
+
+        response.Count.ShouldBe(4);
+        response.Select(r => r.Status).ShouldBe(["pass", "fail", "warn", "info"]);
+    }
+
+    [Test]
+    public async Task Should_Filter_Out_NotApplicable_Results()
+    {
+        var results = new List<HealthCheckResult>
+        {
+            new("Pass Check", HealthCheckStatus.Pass, "all good", "ok", Option<HealthCheckLink>.None),
+            new("NA Check", HealthCheckStatus.NotApplicable, "skip", "skip", Option<HealthCheckLink>.None)
+        };
+
+        _healthCheckService.PerformHealthChecks(Arg.Any<CancellationToken>()).Returns(results);
+
+        List<HealthCheckResponseModel> response =
+            await _handler.Handle(new GetAllHealthCheckResultsForApi(), CancellationToken.None);
+
+        response.Count.ShouldBe(1);
+        response[0].Title.ShouldBe("Pass Check");
+    }
+
+    [Test]
+    public async Task Should_Include_Link_When_Present()
+    {
+        var results = new List<HealthCheckResult>
+        {
+            new(
+                "Linked Check",
+                HealthCheckStatus.Warning,
+                "detail message",
+                "brief",
+                Option<HealthCheckLink>.Some(new HealthCheckLink("https://example.com/docs")))
+        };
+
+        _healthCheckService.PerformHealthChecks(Arg.Any<CancellationToken>()).Returns(results);
+
+        List<HealthCheckResponseModel> response =
+            await _handler.Handle(new GetAllHealthCheckResultsForApi(), CancellationToken.None);
+
+        response[0].Link.ShouldBe("https://example.com/docs");
+        response[0].Detail.ShouldBe("detail message");
+    }
+
+    [Test]
+    public async Task Should_Have_Null_Link_When_Absent()
+    {
+        var results = new List<HealthCheckResult>
+        {
+            new("No Link Check", HealthCheckStatus.Pass, "detail", "brief", Option<HealthCheckLink>.None)
+        };
+
+        _healthCheckService.PerformHealthChecks(Arg.Any<CancellationToken>()).Returns(results);
+
+        List<HealthCheckResponseModel> response =
+            await _handler.Handle(new GetAllHealthCheckResultsForApi(), CancellationToken.None);
+
+        response[0].Link.ShouldBeNull();
+    }
+
+    [Test]
+    public async Task Should_Return_Empty_List_On_Cancellation()
+    {
+        _healthCheckService.PerformHealthChecks(Arg.Any<CancellationToken>())
+            .Returns<Task<List<HealthCheckResult>>>(_ => throw new TaskCanceledException());
+
+        List<HealthCheckResponseModel> response =
+            await _handler.Handle(new GetAllHealthCheckResultsForApi(), CancellationToken.None);
+
+        response.ShouldBeEmpty();
+    }
+}

ErsatzTV.Tests/Application/Libraries/GetLibraryScanStatusHandlerTests.cs

@@ -0,0 +1,32 @@
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core.Api.Libraries;
+using ErsatzTV.Core.Metadata;
+using MediatR;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Libraries;
+
+[TestFixture]
+public class GetLibraryScanStatusHandlerTests
+{
+    [Test]
+    public async Task Handle_Should_Return_Active_Scans()
+    {
+        var mediator = Substitute.For<IMediator>();
+        var scannerProxyService = new ScannerProxyService(mediator);
+        Guid scanId = scannerProxyService.StartScan(42)
+            .Match(
+                Some: id => id,
+                None: () => throw new AssertionException("Expected scan to start"));
+        await scannerProxyService.Progress(scanId, 62.5m);
+
+        var handler = new GetLibraryScanStatusHandler(scannerProxyService);
+
+        List<LibraryScanStatusResponseModel> result =
+            await handler.Handle(new GetLibraryScanStatus(), CancellationToken.None);
+
+        result.ShouldBe([new LibraryScanStatusResponseModel(42, 62.5m)]);
+    }
+}

ErsatzTV.Tests/Application/MediaSources/GetAllMediaSourcesForApiHandlerTests.cs

@@ -0,0 +1,179 @@
+using ErsatzTV.Application.MediaSources;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.MediaSources;
+
+[TestFixture]
+public class GetAllMediaSourcesForApiHandlerTests
+{
+    private InMemoryTvContext _db = null!;
+
+    [SetUp]
+    public async Task SetUp() => _db = await InMemoryTvContext.CreateAsync();
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task Handle_Should_Group_Configured_Libraries_By_Source_With_Item_Counts()
+    {
+        await SeedMediaSources();
+        var handler = new GetAllMediaSourcesForApiHandler(_db.Factory);
+
+        var result = await handler.Handle(new GetAllMediaSourcesForApi(), CancellationToken.None);
+
+        result.Count.ShouldBe(4);
+
+        result[0].Kind.ShouldBe("Local");
+        result[0].Name.ShouldBe("Local");
+        result[0].ConnectionAddress.ShouldBeNull();
+        result[0].Libraries.Single().Name.ShouldBe("Local Movies");
+        result[0].Libraries.Single().LastScan.ShouldBe(new DateTime(2026, 7, 1, 0, 0, 0, DateTimeKind.Utc));
+        result[0].Libraries.Single().ItemCount.ShouldBe(2);
+
+        result[1].Kind.ShouldBe("Emby");
+        result[1].Name.ShouldBe("Emby Server");
+        result[1].ConnectionAddress.ShouldBe("http://emby.local");
+        result[1].Libraries.Single().Name.ShouldBe("Emby Shows");
+        result[1].Libraries.Single().ItemCount.ShouldBe(1);
+
+        result[2].Kind.ShouldBe("Jellyfin");
+        result[2].Name.ShouldBe("Jellyfin Server");
+        result[2].ConnectionAddress.ShouldBe("http://jellyfin.local");
+        result[2].Libraries.ShouldBeEmpty();
+
+        result[3].Kind.ShouldBe("Plex");
+        result[3].Name.ShouldBe("Plex Server");
+        result[3].ConnectionAddress.ShouldBe("http://plex.local");
+        result[3].Libraries.Single().Name.ShouldBe("Plex Movies");
+        result[3].Libraries.Single().ItemCount.ShouldBe(0);
+    }
+
+    [Test]
+    public async Task Handle_Should_Exclude_Unconfigured_And_Not_Synced_Libraries()
+    {
+        await SeedMediaSources();
+        var handler = new GetAllMediaSourcesForApiHandler(_db.Factory);
+
+        var result = await handler.Handle(new GetAllMediaSourcesForApi(), CancellationToken.None);
+
+        result.SelectMany(s => s.Libraries).Select(l => l.Name)
+            .ShouldNotContain("Empty Local");
+        result.SelectMany(s => s.Libraries).Select(l => l.Name)
+            .ShouldNotContain("Disabled Jellyfin");
+    }
+
+    private async Task SeedMediaSources()
+    {
+        await using TvContext context = _db.CreateContext();
+
+        var localSource = new LocalMediaSource
+        {
+            Libraries =
+            [
+                new LocalLibrary
+                {
+                    Name = "Local Movies",
+                    MediaKind = LibraryMediaKind.Movies,
+                    LastScan = new DateTime(2026, 7, 1, 0, 0, 0, DateTimeKind.Utc),
+                    Paths = [MakePath("/media/movies", 2)]
+                },
+                new LocalLibrary
+                {
+                    Name = "Empty Local",
+                    MediaKind = LibraryMediaKind.Shows,
+                    Paths = []
+                }
+            ]
+        };
+
+        var plexSource = new PlexMediaSource
+        {
+            ServerName = "Plex Server",
+            ProductVersion = "1",
+            Platform = "Linux",
+            PlatformVersion = "1",
+            ClientIdentifier = "plex",
+            Connections = [new PlexConnection { IsActive = true, Uri = "http://plex.local" }],
+            PathReplacements = [],
+            Libraries =
+            [
+                new PlexLibrary
+                {
+                    Name = "Plex Movies",
+                    MediaKind = LibraryMediaKind.Movies,
+                    Key = "1",
+                    ShouldSyncItems = true,
+                    Paths = []
+                }
+            ]
+        };
+
+        var embySource = new EmbyMediaSource
+        {
+            ServerName = "Emby Server",
+            OperatingSystem = "Linux",
+            Connections = [new EmbyConnection { Address = "http://emby.local" }],
+            PathReplacements = [],
+            Libraries =
+            [
+                new EmbyLibrary
+                {
+                    Name = "Emby Shows",
+                    MediaKind = LibraryMediaKind.Shows,
+                    ItemId = "emby-shows",
+                    ShouldSyncItems = true,
+                    PathInfos = [],
+                    Paths = [MakePath("/emby/shows", 1)]
+                }
+            ]
+        };
+
+        var jellyfinSource = new JellyfinMediaSource
+        {
+            ServerName = "Jellyfin Server",
+            OperatingSystem = "Linux",
+            Connections = [new JellyfinConnection { Address = "http://jellyfin.local" }],
+            PathReplacements = [],
+            Libraries =
+            [
+                new JellyfinLibrary
+                {
+                    Name = "Disabled Jellyfin",
+                    MediaKind = LibraryMediaKind.Movies,
+                    ItemId = "jellyfin-movies",
+                    ShouldSyncItems = false,
+                    PathInfos = [],
+                    Paths = [MakePath("/jellyfin/movies", 1)]
+                }
+            ]
+        };
+
+        context.MediaSources.AddRange(localSource, plexSource, embySource, jellyfinSource);
+        await context.SaveChangesAsync();
+        context.ChangeTracker.Clear();
+    }
+
+    private static LibraryPath MakePath(string path, int mediaItemCount) =>
+        new()
+        {
+            Path = path,
+            LibraryFolders = [],
+            MediaItems = Enumerable.Range(0, mediaItemCount)
+                .Select(_ => new Movie
+                {
+                    MovieMetadata = [],
+                    MediaVersions = [],
+                    Collections = [],
+                    CollectionItems = [],
+                    TraktListItems = []
+                })
+                .Cast<MediaItem>()
+                .ToList()
+        };
+}

ErsatzTV.Tests/Application/ProgramSchedules/GetProgramScheduleItemsWithDurationsHandlerTests.cs

@@ -0,0 +1,247 @@
+using ErsatzTV.Application.MediaCollections;
+using ErsatzTV.Application.ProgramSchedules;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Interfaces.Repositories;
+using ErsatzTV.Core.Scheduling;
+using MediatR;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.ProgramSchedules;
+
+[TestFixture]
+public class GetProgramScheduleItemsWithDurationsHandlerTests
+{
+    private IMediaCollectionRepository _mediaCollectionRepository = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _mediaCollectionRepository = Substitute.For<IMediaCollectionRepository>();
+    }
+
+    [Test]
+    public async Task Handle_Should_Estimate_Items_And_Total_From_Collection_Durations()
+    {
+        ProgramScheduleItemViewModel one = MakeOneItem(1, 10);
+        ProgramScheduleItemViewModel multipleCount = MakeMultipleItem(2, 10, MultipleMode.Count, "3");
+        ProgramScheduleItemViewModel multipleCollectionSize = MakeMultipleItem(3, 20, MultipleMode.CollectionSize, "0");
+        ProgramScheduleItemViewModel duration = MakeDurationItem(4, TimeSpan.FromMinutes(45));
+        ProgramScheduleItemViewModel flood = MakeFloodItem(5, 10);
+        ProgramScheduleItemViewModel remote = MakeOneItem(6, 30);
+
+        _mediator.Send(Arg.Is<GetProgramScheduleItems>(q => q.Id == 99), Arg.Any<CancellationToken>())
+            .Returns([one, multipleCount, multipleCollectionSize, duration, flood, remote]);
+        _mediaCollectionRepository.GetItems(10)
+            .Returns([MakeMovie(30), MakeMovie(60), MakeMovie(0)]);
+        _mediaCollectionRepository.GetItems(20)
+            .Returns([MakeMovie(10), MakeMovie(20)]);
+        _mediaCollectionRepository.GetItems(30)
+            .Returns([MakeRemoteStreamWithFallbackDuration(20)]);
+
+        var handler = new GetProgramScheduleItemsWithDurationsHandler(_mediator, _mediaCollectionRepository);
+
+        ProgramScheduleItemsWithDurationViewModel result =
+            await handler.Handle(new GetProgramScheduleItemsWithDurations(99), CancellationToken.None);
+
+        result.Items[0].DurationEstimate.ShouldBe(TimeSpan.FromMinutes(45));
+        result.Items[1].DurationEstimate.ShouldBe(TimeSpan.FromMinutes(135));
+        result.Items[2].DurationEstimate.ShouldBe(TimeSpan.FromMinutes(30));
+        result.Items[3].DurationEstimate.ShouldBe(TimeSpan.FromMinutes(45));
+        result.Items[4].DurationEstimate.ShouldBeNull();
+        result.Items[5].DurationEstimate.ShouldBe(TimeSpan.FromMinutes(20));
+        result.TotalDurationEstimate.ShouldBe(TimeSpan.FromMinutes(275));
+    }
+
+    [Test]
+    public async Task Handle_Should_Return_Null_Total_When_No_Items_Can_Be_Estimated()
+    {
+        ProgramScheduleItemViewModel one = MakeOneItem(1, 10);
+        ProgramScheduleItemViewModel flood = MakeFloodItem(2, 10);
+
+        _mediator.Send(Arg.Is<GetProgramScheduleItems>(q => q.Id == 99), Arg.Any<CancellationToken>())
+            .Returns([one, flood]);
+        _mediaCollectionRepository.GetItems(10)
+            .Returns([MakeMovie(0)]);
+
+        var handler = new GetProgramScheduleItemsWithDurationsHandler(_mediator, _mediaCollectionRepository);
+
+        ProgramScheduleItemsWithDurationViewModel result =
+            await handler.Handle(new GetProgramScheduleItemsWithDurations(99), CancellationToken.None);
+
+        result.Items.ShouldAllBe(item => item.DurationEstimate == null);
+        result.TotalDurationEstimate.ShouldBeNull();
+    }
+
+    private static ProgramScheduleItemOneViewModel MakeOneItem(int id, int collectionId) =>
+        new(
+            id,
+            id,
+            StartType.Dynamic,
+            null,
+            null,
+            CollectionType.Collection,
+            MakeCollection(collectionId),
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            PlaybackOrder.Shuffle,
+            MarathonGroupBy.None,
+            false,
+            false,
+            null,
+            FillWithGroupMode.None,
+            null,
+            GuideMode.Normal,
+            null,
+            null,
+            null,
+            null,
+            null,
+            [],
+            [],
+            null,
+            null,
+            null,
+            null);
+
+    private static ProgramScheduleItemMultipleViewModel MakeMultipleItem(
+        int id,
+        int collectionId,
+        MultipleMode multipleMode,
+        string count) =>
+        new(
+            id,
+            id,
+            StartType.Dynamic,
+            null,
+            null,
+            CollectionType.Collection,
+            MakeCollection(collectionId),
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            PlaybackOrder.Shuffle,
+            MarathonGroupBy.None,
+            false,
+            false,
+            null,
+            FillWithGroupMode.None,
+            multipleMode,
+            count,
+            null,
+            GuideMode.Normal,
+            null,
+            null,
+            null,
+            null,
+            null,
+            [],
+            [],
+            null,
+            null,
+            null,
+            null);
+
+    private static ProgramScheduleItemDurationViewModel MakeDurationItem(int id, TimeSpan playoutDuration) =>
+        new(
+            id,
+            id,
+            StartType.Dynamic,
+            null,
+            null,
+            CollectionType.Collection,
+            MakeCollection(10),
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            PlaybackOrder.Shuffle,
+            MarathonGroupBy.None,
+            false,
+            false,
+            null,
+            FillWithGroupMode.None,
+            playoutDuration,
+            TailMode.None,
+            0,
+            null,
+            GuideMode.Normal,
+            null,
+            null,
+            null,
+            null,
+            null,
+            [],
+            [],
+            null,
+            null,
+            null,
+            null);
+
+    private static ProgramScheduleItemFloodViewModel MakeFloodItem(int id, int collectionId) =>
+        new(
+            id,
+            id,
+            StartType.Dynamic,
+            null,
+            null,
+            CollectionType.Collection,
+            MakeCollection(collectionId),
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            null,
+            PlaybackOrder.Shuffle,
+            MarathonGroupBy.None,
+            false,
+            false,
+            null,
+            FillWithGroupMode.None,
+            null,
+            GuideMode.Normal,
+            null,
+            null,
+            null,
+            null,
+            null,
+            [],
+            [],
+            null,
+            null,
+            null,
+            null);
+
+    private static MediaCollectionViewModel MakeCollection(int id) =>
+        new(CollectionType.Collection, id, $"Collection {id}", false, MediaItemState.Normal);
+
+    private static Movie MakeMovie(int minutes) =>
+        new()
+        {
+            MediaVersions = [new MediaVersion { Duration = TimeSpan.FromMinutes(minutes) }]
+        };
+
+    private static RemoteStream MakeRemoteStreamWithFallbackDuration(int minutes) =>
+        new()
+        {
+            Duration = TimeSpan.FromMinutes(minutes),
+            MediaVersions = [new MediaVersion { Duration = TimeSpan.Zero }]
+        };
+}

ErsatzTV.Tests/Application/Watermarks/WatermarkHandlerTests.cs

@@ -0,0 +1,71 @@
+using ErsatzTV.Application.Watermarks;
+using ErsatzTV.Core.Api.Watermarks;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.FFmpeg.State;
+using ErsatzTV.Infrastructure.Data;
+using ErsatzTV.Tests.Support;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Application.Watermarks;
+
+[TestFixture]
+public class WatermarkHandlerTests
+{
+    private InMemoryTvContext _db = null!;
+
+    [SetUp]
+    public async Task SetUp() => _db = await InMemoryTvContext.CreateAsync();
+
+    [TearDown]
+    public async Task TearDown() => await _db.DisposeAsync();
+
+    [Test]
+    public async Task GetAllWatermarksForApi_Should_Return_All_Watermarks()
+    {
+        await SeedWatermark(1, "Bug");
+        await SeedWatermark(2, "Logo");
+
+        var handler = new GetAllWatermarksForApiHandler(_db.Factory);
+
+        List<WatermarkResponseModel> result =
+            await handler.Handle(new GetAllWatermarksForApi(), CancellationToken.None);
+
+        result.Count.ShouldBe(2);
+        result.ShouldContain(new WatermarkResponseModel(1, "Bug"));
+        result.ShouldContain(new WatermarkResponseModel(2, "Logo"));
+    }
+
+    [Test]
+    public async Task GetAllWatermarksForApi_Should_Return_Empty_List_When_None_Exist()
+    {
+        var handler = new GetAllWatermarksForApiHandler(_db.Factory);
+
+        List<WatermarkResponseModel> result =
+            await handler.Handle(new GetAllWatermarksForApi(), CancellationToken.None);
+
+        result.ShouldBeEmpty();
+    }
+
+    private async Task SeedWatermark(int id, string name)
+    {
+        await using TvContext context = _db.CreateContext();
+        context.ChannelWatermarks.Add(new ChannelWatermark
+        {
+            Id = id,
+            Name = name,
+            Mode = ChannelWatermarkMode.Permanent,
+            ImageSource = ChannelWatermarkImageSource.Custom,
+            Image = "watermark.png",
+            Location = WatermarkLocation.BottomRight,
+            Size = WatermarkSize.Scaled,
+            WidthPercent = 10,
+            HorizontalMarginPercent = 2,
+            VerticalMarginPercent = 2,
+            FrequencyMinutes = 15,
+            DurationSeconds = 30,
+            Opacity = 100
+        });
+        await context.SaveChangesAsync();
+    }
+}

ErsatzTV.Tests/Controllers/ArtworkUploadControllerTests.cs

@@ -0,0 +1,164 @@
+using System.Reflection;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+using static LanguageExt.Prelude;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class ArtworkUploadControllerTests
+{
+    private ArtworkUploadController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new ArtworkUploadController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(ArtworkUploadController).GetMethod(nameof(ArtworkUploadController.Upload))
+            ?? throw new AssertionException("Missing action Upload");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("POST");
+        attribute.Template.ShouldBe("/api/artwork/uploads");
+        attribute.Name.ShouldBe("UploadArtwork");
+    }
+
+    [Test]
+    public void Action_Should_Consume_Multipart_Form_Data()
+    {
+        MethodInfo action = typeof(ArtworkUploadController).GetMethod(nameof(ArtworkUploadController.Upload))
+            ?? throw new AssertionException("Missing action Upload");
+
+        var consumes = action.GetCustomAttribute<ConsumesAttribute>();
+        consumes.ShouldNotBeNull();
+        consumes.ContentTypes.ShouldContain("multipart/form-data");
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_When_File_Missing()
+    {
+        IActionResult result = await _controller.Upload(null!, "logo", CancellationToken.None);
+
+        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Status.ShouldBe(422);
+        problem.Title.ShouldBe("Validation failed");
+        await _mediator.DidNotReceive().Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_When_File_Empty()
+    {
+        IFormFile emptyFile = MakeFormFile([], "image/png");
+
+        IActionResult result = await _controller.Upload(emptyFile, "logo", CancellationToken.None);
+
+        result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        await _mediator.DidNotReceive().Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_When_File_Exceeds_Maximum_Size()
+    {
+        var oversizeBytes = new byte[(SystemEnvironment.MaximumUploadMb * 1024 * 1024) + 1];
+        IFormFile oversizeFile = MakeFormFile(oversizeBytes, "image/png");
+
+        IActionResult result = await _controller.Upload(oversizeFile, "logo", CancellationToken.None);
+
+        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Detail.ShouldContain("maximum allowed size");
+        await _mediator.DidNotReceive().Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_For_Unknown_Target()
+    {
+        IFormFile file = MakeFormFile([1, 2, 3], "image/png");
+
+        IActionResult result = await _controller.Upload(file, "poster", CancellationToken.None);
+
+        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Detail.ShouldContain("Unknown upload target");
+        await _mediator.DidNotReceive().Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Send_UploadArtwork_With_Logo_Kind_And_Return_201()
+    {
+        IFormFile file = MakeFormFile([1, 2, 3], "image/png");
+        _mediator.Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, ArtworkUploadResponseModel>(
+                new ArtworkUploadResponseModel("iptv/logos/abc.png", "image/png")));
+
+        IActionResult result = await _controller.Upload(file, "logo", CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.StatusCode.ShouldBe(201);
+        created.Location.ShouldBe("/iptv/logos/abc.png?contentType=image%2Fpng");
+        created.Value.ShouldBeOfType<ArtworkUploadResponseModel>()
+            .Path.ShouldBe("iptv/logos/abc.png");
+
+        await _mediator.Received(1).Send(
+            Arg.Is<UploadArtwork>(c => c.ArtworkKind == ArtworkKind.Logo && c.ContentType == "image/png"),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Send_UploadArtwork_With_Watermark_Kind_And_Return_201()
+    {
+        IFormFile file = MakeFormFile([1, 2, 3], "image/webp");
+        _mediator.Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>())
+            .Returns(Right<BaseError, ArtworkUploadResponseModel>(
+                new ArtworkUploadResponseModel("def.webp", "image/webp")));
+
+        IActionResult result = await _controller.Upload(file, "watermark", CancellationToken.None);
+
+        var created = result.ShouldBeOfType<CreatedResult>();
+        created.Location.ShouldBe("/artwork/watermarks/def.webp?contentType=image%2Fwebp");
+
+        await _mediator.Received(1).Send(
+            Arg.Is<UploadArtwork>(c => c.ArtworkKind == ArtworkKind.Watermark),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task Upload_Should_Return_422_On_Handler_Validation_Error()
+    {
+        IFormFile file = MakeFormFile([1, 2, 3], "image/bmp");
+        _mediator.Send(Arg.Any<UploadArtwork>(), Arg.Any<CancellationToken>())
+            .Returns(Left<BaseError, ArtworkUploadResponseModel>(BaseError.New("unsupported content type")));
+
+        IActionResult result = await _controller.Upload(file, "logo", CancellationToken.None);
+
+        var unprocessable = result.ShouldBeOfType<UnprocessableEntityObjectResult>();
+        var problem = unprocessable.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Status.ShouldBe(422);
+        problem.Title.ShouldBe("Validation failed");
+    }
+
+    private static IFormFile MakeFormFile(byte[] bytes, string contentType) =>
+        new FormFile(new MemoryStream(bytes), 0, bytes.Length, "file", "upload.bin")
+        {
+            Headers = new HeaderDictionary(),
+            ContentType = contentType
+        };
+}

ErsatzTV.Tests/Controllers/ChannelControllerTests.cs

@@ -6,8 +6,10 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Controllers.Api;
 using ErsatzTV.Controllers.Api.Requests;
 using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Channels;
 using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Errors;
+using ErsatzTV.Core.Scheduling;
 using LanguageExt;
 using static LanguageExt.Prelude;
 using MediatR;
@@ -23,15 +25,15 @@ namespace ErsatzTV.Tests.Controllers;
 public class ChannelControllerTests
 {
     private IMediator _mediator = null!;
+    private Channel<IBackgroundServiceRequest> _workerChannel = null!;
     private ChannelController _controller = null!;
 
     [SetUp]
     public void SetUp()
     {
         _mediator = Substitute.For<IMediator>();
-        ChannelWriter<IBackgroundServiceRequest> writer =
-            System.Threading.Channels.Channel.CreateUnbounded<IBackgroundServiceRequest>().Writer;
-        _controller = new ChannelController(writer, _mediator);
+        _workerChannel = System.Threading.Channels.Channel.CreateUnbounded<IBackgroundServiceRequest>();
+        _controller = new ChannelController(_workerChannel.Writer, _mediator);
     }
 
     [Test]
@@ -125,6 +127,35 @@ public class ChannelControllerTests
         result.ShouldBeOfType<NotFoundObjectResult>();
     }
 
+    [Test]
+    public async Task GetGuide_Should_Map_Query_And_Return_Model()
+    {
+        var start = new DateTimeOffset(2026, 1, 1, 0, 0, 0, TimeSpan.Zero);
+        var end = new DateTimeOffset(2026, 1, 3, 0, 0, 0, TimeSpan.Zero);
+        var model = new ChannelGuideResponseModel(start, end, []);
+        _mediator.Send(Arg.Any<GetChannelGuideData>(), Arg.Any<CancellationToken>()).Returns(model);
+
+        ChannelGuideResponseModel result = await _controller.GetGuide(start, end, CancellationToken.None);
+
+        result.ShouldBe(model);
+        await _mediator.Received(1).Send(
+            Arg.Is<GetChannelGuideData>(q => q.Start == start && q.End == end),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetGuide_Should_Pass_Null_Bounds_Through()
+    {
+        var model = new ChannelGuideResponseModel(DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, []);
+        _mediator.Send(Arg.Any<GetChannelGuideData>(), Arg.Any<CancellationToken>()).Returns(model);
+
+        await _controller.GetGuide(null, null, CancellationToken.None);
+
+        await _mediator.Received(1).Send(
+            Arg.Is<GetChannelGuideData>(q => q.Start == null && q.End == null),
+            Arg.Any<CancellationToken>());
+    }
+
     [Test]
     public async Task GetById_Should_Return_200_For_Some()
     {
@@ -157,7 +188,7 @@ public class ChannelControllerTests
         _mediator.Send(Arg.Any<GetPlayoutIdByChannelNumber>(), Arg.Any<CancellationToken>())
             .Returns(Option<int>.None);
 
-        IActionResult result = await _controller.ResetPlayout("404");
+        IActionResult result = await _controller.ResetPlayout("404", mode: null, CancellationToken.None);
 
         var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
         var problemDetails = notFound.Value.ShouldBeOfType<ProblemDetails>();
@@ -165,6 +196,53 @@ public class ChannelControllerTests
         problemDetails.Title.ShouldBe("Resource not found");
     }
 
+    [TestCase(PlayoutScheduleKind.Classic, PlayoutBuildMode.Refresh)]
+    [TestCase(PlayoutScheduleKind.Block, PlayoutBuildMode.Reset)]
+    [TestCase(PlayoutScheduleKind.Sequential, PlayoutBuildMode.Reset)]
+    public async Task ResetPlayout_Should_Default_Mode_By_ScheduleKind(
+        PlayoutScheduleKind scheduleKind,
+        PlayoutBuildMode expectedMode)
+    {
+        _mediator.Send(Arg.Any<GetPlayoutIdByChannelNumber>(), Arg.Any<CancellationToken>())
+            .Returns(Option<int>.Some(9));
+        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<PlayoutNameViewModel>.Some(MakePlayout(9, scheduleKind)));
+
+        IActionResult result = await _controller.ResetPlayout("5", mode: null, CancellationToken.None);
+
+        result.ShouldBeOfType<OkResult>();
+        _workerChannel.Reader.TryRead(out IBackgroundServiceRequest? request).ShouldBeTrue();
+        var buildPlayout = request.ShouldBeOfType<BuildPlayout>();
+        buildPlayout.PlayoutId.ShouldBe(9);
+        buildPlayout.Mode.ShouldBe(expectedMode);
+    }
+
+    [Test]
+    public async Task ResetPlayout_Should_Honor_Explicit_Mode()
+    {
+        _mediator.Send(Arg.Any<GetPlayoutIdByChannelNumber>(), Arg.Any<CancellationToken>())
+            .Returns(Option<int>.Some(9));
+
+        IActionResult result = await _controller.ResetPlayout("5", PlayoutBuildMode.Continue, CancellationToken.None);
+
+        result.ShouldBeOfType<OkResult>();
+        _workerChannel.Reader.TryRead(out IBackgroundServiceRequest? request).ShouldBeTrue();
+        request.ShouldBeOfType<BuildPlayout>().Mode.ShouldBe(PlayoutBuildMode.Continue);
+        await _mediator.DidNotReceive().Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>());
+    }
+
+    private static PlayoutNameViewModel MakePlayout(int id, PlayoutScheduleKind scheduleKind) =>
+        new(
+            id,
+            scheduleKind,
+            "Channel",
+            "5",
+            ChannelPlayoutMode.Continuous,
+            "Schedule",
+            string.Empty,
+            null,
+            null);
+
     private static ChannelViewModel MakeVm(int id) =>
         new(
             id,

ErsatzTV.Tests/Controllers/FillerPresetControllerTests.cs

@@ -0,0 +1,63 @@
+using System.Reflection;
+using ErsatzTV.Application.Filler;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.Filler;
+using MediatR;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class FillerPresetControllerTests
+{
+    private FillerPresetController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new FillerPresetController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(FillerPresetController).GetMethod(nameof(FillerPresetController.GetAll))
+            ?? throw new AssertionException("Missing action GetAll");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("GET");
+        attribute.Template.ShouldBe("/api/filler-presets");
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_FillerPresets()
+    {
+        List<FillerPresetResponseModel> models =
+        [
+            new FillerPresetResponseModel(1, "Intro"),
+            new FillerPresetResponseModel(2, "Outro")
+        ];
+        _mediator.Send(Arg.Any<GetAllFillerPresetsForApi>(), Arg.Any<CancellationToken>())
+            .Returns(models);
+
+        List<FillerPresetResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBe(models);
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_Empty_List_When_None_Exist()
+    {
+        _mediator.Send(Arg.Any<GetAllFillerPresetsForApi>(), Arg.Any<CancellationToken>())
+            .Returns([]);
+
+        List<FillerPresetResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBeEmpty();
+    }
+}

ErsatzTV.Tests/Controllers/GraphicsElementControllerTests.cs

@@ -0,0 +1,63 @@
+using System.Reflection;
+using ErsatzTV.Application.Graphics;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.Graphics;
+using MediatR;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class GraphicsElementControllerTests
+{
+    private GraphicsElementController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new GraphicsElementController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(GraphicsElementController).GetMethod(nameof(GraphicsElementController.GetAll))
+            ?? throw new AssertionException("Missing action GetAll");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("GET");
+        attribute.Template.ShouldBe("/api/graphics-elements");
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_GraphicsElements()
+    {
+        List<GraphicsElementResponseModel> models =
+        [
+            new GraphicsElementResponseModel(1, "Lower Third (lower-third.png)"),
+            new GraphicsElementResponseModel(2, "bug.png")
+        ];
+        _mediator.Send(Arg.Any<GetAllGraphicsElementsForApi>(), Arg.Any<CancellationToken>())
+            .Returns(models);
+
+        List<GraphicsElementResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBe(models);
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_Empty_List_When_None_Exist()
+    {
+        _mediator.Send(Arg.Any<GetAllGraphicsElementsForApi>(), Arg.Any<CancellationToken>())
+            .Returns([]);
+
+        List<GraphicsElementResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBeEmpty();
+    }
+}

ErsatzTV.Tests/Controllers/HealthControllerTests.cs

@@ -0,0 +1,65 @@
+using System.Reflection;
+using ErsatzTV.Application.Health;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.Health;
+using MediatR;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class HealthControllerTests
+{
+    private IMediator _mediator = null!;
+    private HealthController _controller = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new HealthController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(HealthController).GetMethod(nameof(HealthController.GetAll))
+            ?? throw new AssertionException("Missing action GetAll");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("GET");
+        attribute.Template.ShouldBe("/api/health");
+        attribute.Name.ShouldBe("GetHealthChecks");
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_Results_From_Mediator()
+    {
+        var expected = new List<HealthCheckResponseModel>
+        {
+            new("Check One", "pass", "all good", null),
+            new("Check Two", "fail", "broken", "https://example.com")
+        };
+
+        _mediator.Send(Arg.Any<GetAllHealthCheckResultsForApi>(), Arg.Any<CancellationToken>())
+            .Returns(expected);
+
+        List<HealthCheckResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBe(expected);
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_Empty_List_When_None_Exist()
+    {
+        _mediator.Send(Arg.Any<GetAllHealthCheckResultsForApi>(), Arg.Any<CancellationToken>())
+            .Returns([]);
+
+        List<HealthCheckResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBeEmpty();
+    }
+}

ErsatzTV.Tests/Controllers/LibrariesControllerTests.cs

@@ -0,0 +1,55 @@
+using System.Reflection;
+using ErsatzTV.Application.Libraries;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.Libraries;
+using ErsatzTV.Core.Interfaces.Repositories;
+using MediatR;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class LibrariesControllerTests
+{
+    private LibrariesController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new LibrariesController(Substitute.For<ITelevisionRepository>(), _mediator);
+    }
+
+    [Test]
+    public void ScanStatus_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(LibrariesController).GetMethod(nameof(LibrariesController.GetScanStatus))
+            ?? throw new AssertionException("Missing action GetScanStatus");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("GET");
+        attribute.Template.ShouldBe("/api/libraries/scan-status");
+        attribute.Name.ShouldBe("GetLibraryScanStatus");
+    }
+
+    [Test]
+    public async Task GetScanStatus_Should_Return_Results_From_Mediator()
+    {
+        var expected = new List<LibraryScanStatusResponseModel>
+        {
+            new(1, 42.5m),
+            new(2, 99m)
+        };
+
+        _mediator.Send(Arg.Any<GetLibraryScanStatus>(), Arg.Any<CancellationToken>())
+            .Returns(expected);
+
+        List<LibraryScanStatusResponseModel> result = await _controller.GetScanStatus(CancellationToken.None);
+
+        result.ShouldBe(expected);
+    }
+}

ErsatzTV.Tests/Controllers/MediaSourcesControllerTests.cs

@@ -0,0 +1,59 @@
+using System.Reflection;
+using ErsatzTV.Application.MediaSources;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.MediaSources;
+using ErsatzTV.Core.Domain;
+using MediatR;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class MediaSourcesControllerTests
+{
+    private MediaSourcesController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new MediaSourcesController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(MediaSourcesController).GetMethod(nameof(MediaSourcesController.GetAll))
+            ?? throw new AssertionException("Missing action GetAll");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("GET");
+        attribute.Template.ShouldBe("/api/media-sources");
+        attribute.Name.ShouldBe("GetMediaSources");
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_Results_From_Mediator()
+    {
+        var expected = new List<MediaSourceResponseModel>
+        {
+            new(
+                1,
+                "Local",
+                "Local",
+                null,
+                [new MediaSourceLibraryResponseModel(10, "Movies", LibraryMediaKind.Movies, null, 3)])
+        };
+
+        _mediator.Send(Arg.Any<GetAllMediaSourcesForApi>(), Arg.Any<CancellationToken>())
+            .Returns(expected);
+
+        List<MediaSourceResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBe(expected);
+    }
+}

ErsatzTV.Tests/Controllers/OpenApiErrorResponseContractTests.cs

@@ -68,6 +68,8 @@ public class OpenApiErrorResponseContractTests
     [TestCase("/api/playouts", "post", "422")]
     [TestCase("/api/playouts/{id}", "delete", "404")]
     [TestCase("/api/playouts/{id}", "delete", "422")]
+    [TestCase("/api/playouts/{id}/items", "get", "404")]
+    [TestCase("/api/artwork/uploads", "post", "422")]
     [TestCase("/api/ffmpeg/profiles/{id}", "get", "404")]
     [TestCase("/api/ffmpeg/profiles", "post", "404")]
     [TestCase("/api/ffmpeg/profiles", "post", "401")]

ErsatzTV.Tests/Controllers/PlayoutControllerTests.cs

@@ -5,6 +5,7 @@ using ErsatzTV.Controllers.Api.Requests;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Api.Playouts;
 using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Core.Errors;
 using LanguageExt;
 using MediatR;
@@ -34,8 +35,12 @@ public class PlayoutControllerTests
     [Test]
     public void Controller_Should_Expose_Idiomatic_Rest_Routes()
     {
+        ShouldHaveActionRoute(nameof(PlayoutController.GetAll), "GET", "/api/playouts");
         ShouldHaveActionRoute(nameof(PlayoutController.GetById), "GET", "/api/playouts/{id:int}");
+        ShouldHaveActionRoute(nameof(PlayoutController.GetItems), "GET", "/api/playouts/{id:int}/items");
+        ShouldHaveActionRoute(nameof(PlayoutController.GetWarningsCount), "GET", "/api/playouts/warnings/count");
         ShouldHaveActionRoute(nameof(PlayoutController.Create), "POST", "/api/playouts");
+        ShouldHaveActionRoute(nameof(PlayoutController.ResetAll), "POST", "/api/playouts/reset-all");
         ShouldHaveActionRoute(nameof(PlayoutController.Delete), "DELETE", "/api/playouts/{id:int}");
     }
 
@@ -162,6 +167,130 @@ public class PlayoutControllerTests
         problem.Title.ShouldBe("Resource not found");
     }
 
+    [Test]
+    public async Task GetAll_Should_Project_Paged_List_With_BuildStatus()
+    {
+        var buildStatus = new PlayoutBuildStatus
+        {
+            LastBuild = new DateTimeOffset(2026, 7, 2, 10, 0, 0, TimeSpan.Zero),
+            Success = false,
+            Message = "boom"
+        };
+        PlayoutNameViewModel vm = MakePlayout(9) with
+        {
+            BuildStatus = buildStatus,
+            DbDailyRebuildTime = TimeSpan.FromHours(4)
+        };
+        _mediator.Send(Arg.Any<GetPagedPlayouts>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedPlayoutsViewModel(1, [vm]));
+
+        PagedPlayoutsResponseModel result = await _controller.GetAll("q", 2, 25, CancellationToken.None);
+
+        result.TotalCount.ShouldBe(1);
+        PlayoutListItemResponseModel item = result.Page.Single();
+        item.Id.ShouldBe(9);
+        item.ChannelNumber.ShouldBe("101");
+        item.ChannelName.ShouldBe("Channel");
+        item.ScheduleKind.ShouldBe(PlayoutScheduleKind.Classic);
+        item.ScheduleName.ShouldBe("Schedule");
+        item.DailyRebuildTime.ShouldBe(TimeSpan.FromHours(4));
+        item.BuildStatus.ShouldNotBeNull();
+        item.BuildStatus.Success.ShouldBeFalse();
+        item.BuildStatus.Message.ShouldBe("boom");
+        item.BuildStatus.LastBuild.ShouldBe(buildStatus.LastBuild);
+
+        await _mediator.Received(1).Send(
+            Arg.Is<GetPagedPlayouts>(q => q.Query == "q" && q.PageNum == 2 && q.PageSize == 25),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetAll_Should_Emit_Null_BuildStatus_When_Absent()
+    {
+        PlayoutNameViewModel vm = MakePlayout(9) with { BuildStatus = null };
+        _mediator.Send(Arg.Any<GetPagedPlayouts>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedPlayoutsViewModel(1, [vm]));
+
+        PagedPlayoutsResponseModel result = await _controller.GetAll("", 0, 100, CancellationToken.None);
+
+        result.Page.Single().BuildStatus.ShouldBeNull();
+    }
+
+    [Test]
+    public async Task GetItems_Should_Project_Items_And_Null_FillerKind_For_Gaps()
+    {
+        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<PlayoutNameViewModel>.Some(MakePlayout(9)));
+
+        var item = new PlayoutItemViewModel(
+            "Movie",
+            new DateTimeOffset(2026, 7, 2, 12, 0, 0, TimeSpan.Zero),
+            new DateTimeOffset(2026, 7, 2, 13, 0, 0, TimeSpan.Zero),
+            "1:00:00",
+            string.Empty,
+            Some(FillerKind.MidRoll));
+        var gap = new PlayoutItemViewModel(
+            "UNSCHEDULED",
+            new DateTimeOffset(2026, 7, 2, 13, 0, 0, TimeSpan.Zero),
+            new DateTimeOffset(2026, 7, 2, 13, 30, 0, TimeSpan.Zero),
+            "30:00",
+            string.Empty,
+            Option<FillerKind>.None);
+        _mediator.Send(Arg.Any<GetFuturePlayoutItemsById>(), Arg.Any<CancellationToken>())
+            .Returns(new PagedPlayoutItemsViewModel(2, [item, gap]));
+
+        IActionResult actionResult = await _controller.GetItems(9, showFiller: true, 1, 10, CancellationToken.None);
+
+        var result = actionResult.ShouldBeOfType<OkObjectResult>().Value.ShouldBeOfType<PagedPlayoutItemsResponseModel>();
+        result.TotalCount.ShouldBe(2);
+        result.Page[0].Title.ShouldBe("Movie");
+        result.Page[0].Duration.ShouldBe("1:00:00");
+        result.Page[0].FillerKind.ShouldBe(FillerKind.MidRoll);
+        result.Page[1].Title.ShouldBe("UNSCHEDULED");
+        result.Page[1].FillerKind.ShouldBeNull();
+
+        await _mediator.Received(1).Send(
+            Arg.Is<GetFuturePlayoutItemsById>(q =>
+                q.PlayoutId == 9 && q.ShowFiller && q.PageNum == 1 && q.PageSize == 10),
+            Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetItems_Should_Return_404_For_Unknown_Playout_With_ProblemDetails()
+    {
+        _mediator.Send(Arg.Any<GetPlayoutById>(), Arg.Any<CancellationToken>())
+            .Returns(Option<PlayoutNameViewModel>.None);
+
+        IActionResult result = await _controller.GetItems(404, showFiller: false, 0, 100, CancellationToken.None);
+
+        var notFound = result.ShouldBeOfType<NotFoundObjectResult>();
+        var problem = notFound.Value.ShouldBeOfType<ProblemDetails>();
+        problem.Status.ShouldBe(404);
+        problem.Title.ShouldBe("Resource not found");
+
+        await _mediator.DidNotReceive().Send(Arg.Any<GetFuturePlayoutItemsById>(), Arg.Any<CancellationToken>());
+    }
+
+    [Test]
+    public async Task GetWarningsCount_Should_Return_Count()
+    {
+        _mediator.Send(Arg.Any<GetPlayoutWarningsCount>(), Arg.Any<CancellationToken>())
+            .Returns(7);
+
+        int result = await _controller.GetWarningsCount(CancellationToken.None);
+
+        result.ShouldBe(7);
+    }
+
+    [Test]
+    public async Task ResetAll_Should_Return_202_And_Send_Command()
+    {
+        IActionResult result = await _controller.ResetAll(CancellationToken.None);
+
+        result.ShouldBeOfType<AcceptedResult>();
+        await _mediator.Received(1).Send(Arg.Any<ResetAllPlayouts>(), Arg.Any<CancellationToken>());
+    }
+
     private static PlayoutNameViewModel MakePlayout(int id) =>
         new(
             id,
@@ -183,7 +312,13 @@ public class PlayoutControllerTests
             vm.PlayoutMode,
             vm.ScheduleName,
             vm.ScheduleFile,
-            vm.DbDailyRebuildTime);
+            vm.DbDailyRebuildTime,
+            vm.BuildStatus is null
+                ? null
+                : new PlayoutBuildStatusResponseModel(
+                    vm.BuildStatus.LastBuild,
+                    vm.BuildStatus.Success,
+                    vm.BuildStatus.Message));
 
     private static void ShouldHaveActionRoute(string actionName, string httpMethod, string route)
     {

ErsatzTV.Tests/Controllers/ScheduleControllerTests.cs

@@ -189,14 +189,18 @@ public class ScheduleControllerTests
     public async Task GetItems_Should_Return_200_With_Items()
     {
         List<ProgramScheduleItemViewModel> items = [MakeOneItem(11)];
+        var response = new ProgramScheduleItemsWithDurationViewModel(items, TimeSpan.FromMinutes(25));
         _mediator.Send(Arg.Any<GetProgramScheduleById>(), Arg.Any<CancellationToken>())
             .Returns(Option<ProgramScheduleViewModel>.Some(MakeSchedule(4, "Daily")));
-        _mediator.Send(Arg.Any<GetProgramScheduleItems>(), Arg.Any<CancellationToken>())
-            .Returns(items);
+        _mediator.Send(Arg.Any<GetProgramScheduleItemsWithDurations>(), Arg.Any<CancellationToken>())
+            .Returns(response);
 
         IActionResult result = await _controller.GetItems(4, CancellationToken.None);
 
-        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBe(items);
+        result.ShouldBeOfType<OkObjectResult>().Value.ShouldBe(response);
+        await _mediator.Received(1).Send(
+            Arg.Is<GetProgramScheduleItemsWithDurations>(q => q.Id == 4),
+            Arg.Any<CancellationToken>());
     }
 
     [Test]

ErsatzTV.Tests/Controllers/WatermarkControllerTests.cs

@@ -0,0 +1,63 @@
+using System.Reflection;
+using ErsatzTV.Application.Watermarks;
+using ErsatzTV.Controllers.Api;
+using ErsatzTV.Core.Api.Watermarks;
+using MediatR;
+using Microsoft.AspNetCore.Mvc.Routing;
+using NSubstitute;
+using NUnit.Framework;
+using Shouldly;
+
+namespace ErsatzTV.Tests.Controllers;
+
+[TestFixture]
+public class WatermarkControllerTests
+{
+    private WatermarkController _controller = null!;
+    private IMediator _mediator = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mediator = Substitute.For<IMediator>();
+        _controller = new WatermarkController(_mediator);
+    }
+
+    [Test]
+    public void Controller_Should_Expose_Idiomatic_Rest_Route()
+    {
+        MethodInfo action = typeof(WatermarkController).GetMethod(nameof(WatermarkController.GetAll))
+            ?? throw new AssertionException("Missing action GetAll");
+
+        HttpMethodAttribute attribute = action.GetCustomAttributes<HttpMethodAttribute>(inherit: true).Single();
+        attribute.HttpMethods.ShouldContain("GET");
+        attribute.Template.ShouldBe("/api/watermarks");
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_Watermarks()
+    {
+        List<WatermarkResponseModel> models =
+        [
+            new WatermarkResponseModel(1, "Corner Logo"),
+            new WatermarkResponseModel(2, "Ticker")
+        ];
+        _mediator.Send(Arg.Any<GetAllWatermarksForApi>(), Arg.Any<CancellationToken>())
+            .Returns(models);
+
+        List<WatermarkResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBe(models);
+    }
+
+    [Test]
+    public async Task GetAll_Should_Return_Empty_List_When_None_Exist()
+    {
+        _mediator.Send(Arg.Any<GetAllWatermarksForApi>(), Arg.Any<CancellationToken>())
+            .Returns([]);
+
+        List<WatermarkResponseModel> result = await _controller.GetAll(CancellationToken.None);
+
+        result.ShouldBeEmpty();
+    }
+}

ErsatzTV/Controllers/Api/ArtworkUploadController.cs

@@ -0,0 +1,85 @@
+using System.ComponentModel;
+using ErsatzTV.Application.Artworks;
+using ErsatzTV.Core;
+using ErsatzTV.Core.Api.Artwork;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Extensions;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class ArtworkUploadController(IMediator mediator) : ControllerBase
+{
+    [HttpPost("/api/artwork/uploads", Name = "UploadArtwork")]
+    [Consumes("multipart/form-data")]
+    [Tags("Artwork")]
+    [EndpointSummary("Upload channel logo or watermark artwork")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ArtworkUploadResponseModel), StatusCodes.Status201Created)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status422UnprocessableEntity)]
+    public async Task<IActionResult> Upload(
+        IFormFile file,
+        [FromForm] [Description("Artwork target: 'logo' (default) or 'watermark'")] string target,
+        CancellationToken cancellationToken)
+    {
+        if (file is null || file.Length == 0)
+        {
+            return BaseError.New("A non-empty image file is required").ToErrorResult();
+        }
+
+        long maxBytes = (long)SystemEnvironment.MaximumUploadMb * 1024 * 1024;
+        if (file.Length > maxBytes)
+        {
+            return BaseError.New($"Image exceeds the maximum allowed size of {SystemEnvironment.MaximumUploadMb} MB")
+                .ToErrorResult();
+        }
+
+        if (!TryParseTarget(target, out ArtworkKind artworkKind))
+        {
+            return BaseError.New($"Unknown upload target '{target}'; expected 'logo' or 'watermark'").ToErrorResult();
+        }
+
+        await using Stream stream = file.OpenReadStream();
+        Either<BaseError, ArtworkUploadResponseModel> result = await mediator.Send(
+            new UploadArtwork(stream, file.ContentType, artworkKind),
+            cancellationToken);
+
+        return result.ToCreatedResult(
+            value => LocationFor(artworkKind, value.Path, value.ContentType),
+            value => value);
+    }
+
+    // "logo" (default) and "watermark" are the two channel-artwork surfaces the API exposes today.
+    private static bool TryParseTarget(string target, out ArtworkKind artworkKind)
+    {
+        switch ((target ?? string.Empty).Trim().ToLowerInvariant())
+        {
+            case "":
+            case "logo":
+                artworkKind = ArtworkKind.Logo;
+                return true;
+            case "watermark":
+                artworkKind = ArtworkKind.Watermark;
+                return true;
+            default:
+                artworkKind = ArtworkKind.Logo;
+                return false;
+        }
+    }
+
+    // Both GetImage (IptvController) and GetWatermark (ArtworkController) require a contentType
+    // query param to serve the cached file, so the Location header must carry it too.
+    private static string LocationFor(ArtworkKind artworkKind, string path, string contentType)
+    {
+        string encodedContentType = Uri.EscapeDataString(contentType);
+        return artworkKind switch
+        {
+            // logo paths already carry the servable prefix ("iptv/logos/{file}")
+            ArtworkKind.Logo => $"/{path}?contentType={encodedContentType}",
+            _ => $"/artwork/watermarks/{path}?contentType={encodedContentType}"
+        };
+    }
+}

ErsatzTV/Controllers/Api/ChannelController.cs

@@ -6,6 +6,7 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Controllers.Api.Requests;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Api.Channels;
+using ErsatzTV.Core.Domain;
 using ErsatzTV.Core.Scheduling;
 using ErsatzTV.Extensions;
 using MediatR;
@@ -21,6 +22,20 @@ public class ChannelController(ChannelWriter<IBackgroundServiceRequest> workerCh
     [EndpointGroupName("general")]
     public async Task<List<ChannelResponseModel>> GetAll() => await mediator.Send(new GetAllChannelsForApi());
 
+    [HttpGet("/api/guide")]
+    [Tags("Channels")]
+    [EndpointSummary("Get the JSON channel guide (EPG)")]
+    [EndpointDescription(
+        "Returns per-channel programme arrays for the EPG grid. When omitted, start defaults to now, " +
+        "and end defaults to start plus the configured XmltvDaysToBuild window.")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(ChannelGuideResponseModel), StatusCodes.Status200OK)]
+    public async Task<ChannelGuideResponseModel> GetGuide(
+        [FromQuery] DateTimeOffset? start,
+        [FromQuery] DateTimeOffset? end,
+        CancellationToken cancellationToken) =>
+        await mediator.Send(new GetChannelGuideData(start, end), cancellationToken);
+
     [HttpGet("/api/channels/{id:int}", Name = "GetChannelById")]
     [Tags("Channels")]
     [EndpointSummary("Get a channel by id")]
@@ -90,18 +105,42 @@ public class ChannelController(ChannelWriter<IBackgroundServiceRequest> workerCh
     [HttpPost("/api/channels/{channelNumber}/playout/reset")]
     [Tags("Channels")]
     [EndpointSummary("Reset channel playout")]
+    [EndpointDescription(
+        "When mode is omitted, classic playouts use Refresh (rebuild while maintaining collection " +
+        "progress) and all other playout kinds use Reset (rebuild from scratch), matching the Blazor UI. " +
+        "Pass mode to force a specific PlayoutBuildMode.")]
     [EndpointGroupName("general")]
     [ProducesResponseType(StatusCodes.Status200OK)]
     [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
-    public async Task<IActionResult> ResetPlayout(string channelNumber)
+    public async Task<IActionResult> ResetPlayout(
+        string channelNumber,
+        [FromQuery] PlayoutBuildMode? mode,
+        CancellationToken cancellationToken)
     {
-        Option<int> maybePlayoutId = await mediator.Send(new GetPlayoutIdByChannelNumber(channelNumber));
+        Option<int> maybePlayoutId =
+            await mediator.Send(new GetPlayoutIdByChannelNumber(channelNumber), cancellationToken);
         foreach (int playoutId in maybePlayoutId)
         {
-            await workerChannel.WriteAsync(new BuildPlayout(playoutId, PlayoutBuildMode.Reset));
+            PlayoutBuildMode buildMode = mode ?? await DefaultResetMode(playoutId, cancellationToken);
+            await workerChannel.WriteAsync(new BuildPlayout(playoutId, buildMode), cancellationToken);
             return new OkResult();
         }
 
         return ApiResults.NotFoundProblem();
     }
+
+    // Match Blazor's Playouts.razor reset semantics: classic playouts refresh (preserve progress),
+    // every other kind resets from scratch.
+    private async Task<PlayoutBuildMode> DefaultResetMode(int playoutId, CancellationToken cancellationToken)
+    {
+        Option<PlayoutNameViewModel> maybePlayout =
+            await mediator.Send(new GetPlayoutById(playoutId), cancellationToken);
+        return maybePlayout.Match(
+            Some: vm => vm.ScheduleKind switch
+            {
+                PlayoutScheduleKind.Classic => PlayoutBuildMode.Refresh,
+                _ => PlayoutBuildMode.Reset
+            },
+            None: () => PlayoutBuildMode.Reset);
+    }
 }

ErsatzTV/Controllers/Api/FillerPresetController.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Application.Filler;
+using ErsatzTV.Core.Api.Filler;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class FillerPresetController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/filler-presets", Name = "GetFillerPresets")]
+    [Tags("Filler Presets")]
+    [EndpointSummary("Get all filler presets")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<FillerPresetResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<FillerPresetResponseModel>> GetAll(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetAllFillerPresetsForApi(), cancellationToken);
+}

ErsatzTV/Controllers/Api/GraphicsElementController.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Application.Graphics;
+using ErsatzTV.Core.Api.Graphics;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class GraphicsElementController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/graphics-elements", Name = "GetGraphicsElements")]
+    [Tags("Graphics Elements")]
+    [EndpointSummary("Get all graphics elements")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<GraphicsElementResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<GraphicsElementResponseModel>> GetAll(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetAllGraphicsElementsForApi(), cancellationToken);
+}

ErsatzTV/Controllers/Api/HealthController.cs

@@ -0,0 +1,18 @@
+using ErsatzTV.Application.Health;
+using ErsatzTV.Core.Api.Health;
+using MediatR;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class HealthController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/health", Name = "GetHealthChecks")]
+    [Tags("Health")]
+    [EndpointSummary("Get health check results")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<HealthCheckResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<HealthCheckResponseModel>> GetAll(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetAllHealthCheckResultsForApi(), cancellationToken);
+}

ErsatzTV/Controllers/Api/LibrariesController.cs

@@ -1,14 +1,23 @@
 using ErsatzTV.Application.Libraries;
+using ErsatzTV.Core.Api.Libraries;
 using ErsatzTV.Core.Interfaces.Repositories;
 using MediatR;
+using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 
 namespace ErsatzTV.Controllers.Api;
 
 [ApiController]
 [EndpointGroupName("general")]
-public class LibrariesController(ITelevisionRepository televisionRepository, IMediator mediator)
+public class LibrariesController(ITelevisionRepository televisionRepository, IMediator mediator) : ControllerBase
 {
+    [HttpGet("/api/libraries/scan-status", Name = "GetLibraryScanStatus")]
+    [Tags("Libraries")]
+    [EndpointSummary("Get active library scan status")]
+    [ProducesResponseType(typeof(List<LibraryScanStatusResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<LibraryScanStatusResponseModel>> GetScanStatus(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetLibraryScanStatus(), cancellationToken);
+
     [HttpPost("/api/libraries/{id:int}/scan")]
     [Tags("Libraries")]
     [EndpointSummary("Scan library")]

ErsatzTV/Controllers/Api/MediaSourcesController.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Application.MediaSources;
+using ErsatzTV.Core.Api.MediaSources;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class MediaSourcesController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/media-sources", Name = "GetMediaSources")]
+    [Tags("Media Sources")]
+    [EndpointSummary("Get all media sources with their libraries")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<MediaSourceResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<MediaSourceResponseModel>> GetAll(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetAllMediaSourcesForApi(), cancellationToken);
+}

ErsatzTV/Controllers/Api/PlayoutController.cs

@@ -3,6 +3,8 @@ using ErsatzTV.Application.Playouts;
 using ErsatzTV.Controllers.Api.Requests;
 using ErsatzTV.Core;
 using ErsatzTV.Core.Api.Playouts;
+using ErsatzTV.Core.Domain;
+using ErsatzTV.Core.Domain.Filler;
 using ErsatzTV.Extensions;
 using MediatR;
 using Microsoft.AspNetCore.Http;
@@ -13,6 +15,32 @@ namespace ErsatzTV.Controllers.Api;
 [ApiController]
 public class PlayoutController(IMediator mediator) : ControllerBase
 {
+    [HttpGet("/api/playouts", Name = "GetPlayouts")]
+    [Tags("Playouts")]
+    [EndpointSummary("List playouts")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(PagedPlayoutsResponseModel), StatusCodes.Status200OK)]
+    public async Task<PagedPlayoutsResponseModel> GetAll(
+        [FromQuery] string query = "",
+        [FromQuery] int pageNum = 0,
+        [FromQuery] int pageSize = 100,
+        CancellationToken cancellationToken = default)
+    {
+        PagedPlayoutsViewModel result =
+            await mediator.Send(new GetPagedPlayouts(query, pageNum, pageSize), cancellationToken);
+        return new PagedPlayoutsResponseModel(
+            result.TotalCount,
+            result.Page.Map(ToListItemResponse).ToList());
+    }
+
+    [HttpGet("/api/playouts/warnings/count", Name = "GetPlayoutWarningsCount")]
+    [Tags("Playouts")]
+    [EndpointSummary("Count playouts with a failed build")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(int), StatusCodes.Status200OK)]
+    public async Task<int> GetWarningsCount(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetPlayoutWarningsCount(), cancellationToken);
+
     [HttpGet("/api/playouts/{id:int}", Name = "GetPlayoutById")]
     [Tags("Playouts")]
     [EndpointSummary("Get a playout by id")]
@@ -25,6 +53,34 @@ public class PlayoutController(IMediator mediator) : ControllerBase
         return result.Map(ToResponse).ToGetResult();
     }
 
+    [HttpGet("/api/playouts/{id:int}/items", Name = "GetPlayoutItems")]
+    [Tags("Playouts")]
+    [EndpointSummary("Get upcoming items (and unscheduled gaps) for a playout")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(PagedPlayoutItemsResponseModel), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> GetItems(
+        int id,
+        [FromQuery] bool showFiller = false,
+        [FromQuery] int pageNum = 0,
+        [FromQuery] int pageSize = 100,
+        CancellationToken cancellationToken = default)
+    {
+        Option<PlayoutNameViewModel> maybePlayout = await mediator.Send(new GetPlayoutById(id), cancellationToken);
+        if (maybePlayout.IsNone)
+        {
+            return ApiResults.NotFoundProblem();
+        }
+
+        PagedPlayoutItemsViewModel result = await mediator.Send(
+            new GetFuturePlayoutItemsById(id, showFiller, pageNum, pageSize),
+            cancellationToken);
+        return new OkObjectResult(
+            new PagedPlayoutItemsResponseModel(
+                result.TotalCount,
+                result.Page.Map(ToItemResponse).ToList()));
+    }
+
     [HttpPost("/api/playouts")]
     [Tags("Playouts")]
     [EndpointSummary("Create a classic playout")]
@@ -49,6 +105,17 @@ public class PlayoutController(IMediator mediator) : ControllerBase
             });
     }
 
+    [HttpPost("/api/playouts/reset-all", Name = "ResetAllPlayouts")]
+    [Tags("Playouts")]
+    [EndpointSummary("Reset all playouts")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(StatusCodes.Status202Accepted)]
+    public async Task<IActionResult> ResetAll(CancellationToken cancellationToken)
+    {
+        await mediator.Send(new ResetAllPlayouts(), cancellationToken);
+        return Accepted();
+    }
+
     [HttpDelete("/api/playouts/{id:int}")]
     [Tags("Playouts")]
     [EndpointSummary("Delete a playout")]
@@ -71,5 +138,32 @@ public class PlayoutController(IMediator mediator) : ControllerBase
             vm.PlayoutMode,
             vm.ScheduleName,
             vm.ScheduleFile,
-            vm.DbDailyRebuildTime);
+            vm.DbDailyRebuildTime,
+            ToBuildStatus(vm.BuildStatus));
+
+    private static PlayoutListItemResponseModel ToListItemResponse(PlayoutNameViewModel vm) =>
+        new(
+            vm.PlayoutId,
+            vm.ChannelNumber,
+            vm.ChannelName,
+            vm.ScheduleKind,
+            vm.ScheduleName,
+            vm.DbDailyRebuildTime,
+            ToBuildStatus(vm.BuildStatus));
+
+    private static PlayoutBuildStatusResponseModel ToBuildStatus(PlayoutBuildStatus buildStatus) =>
+        buildStatus is null
+            ? null
+            : new PlayoutBuildStatusResponseModel(
+                buildStatus.LastBuild,
+                buildStatus.Success,
+                buildStatus.Message);
+
+    private static PlayoutItemResponseModel ToItemResponse(PlayoutItemViewModel vm) =>
+        new(
+            vm.Title,
+            vm.Start,
+            vm.Finish,
+            vm.Duration,
+            vm.FillerKind.MatchUnsafe(fk => (FillerKind?)fk, () => null));
 }

ErsatzTV/Controllers/Api/ScheduleController.cs

@@ -99,8 +99,12 @@ public class ScheduleController(IMediator mediator) : ControllerBase
     [HttpGet("/api/schedules/{id:int}/items")]
     [Tags("Schedules")]
     [EndpointSummary("Get schedule items")]
+    [EndpointDescription(
+        "Returns the schedule's items plus a computed, best-effort runtime estimate: each item carries a " +
+        "nullable durationEstimate and the envelope carries a nullable totalDurationEstimate. Estimates are " +
+        "derived from referenced collection/media runtimes and are null when unbounded or unknown.")]
     [EndpointGroupName("general")]
-    [ProducesResponseType(typeof(List<ProgramScheduleItemViewModel>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ProgramScheduleItemsWithDurationViewModel), StatusCodes.Status200OK)]
     [ProducesResponseType(typeof(ProblemDetails), StatusCodes.Status404NotFound)]
     public async Task<IActionResult> GetItems(int id, CancellationToken cancellationToken)
     {
@@ -110,8 +114,8 @@ public class ScheduleController(IMediator mediator) : ControllerBase
             return ApiResults.NotFoundProblem();
         }
 
-        List<ProgramScheduleItemViewModel> items =
-            await mediator.Send(new GetProgramScheduleItems(id), cancellationToken);
+        ProgramScheduleItemsWithDurationViewModel items =
+            await mediator.Send(new GetProgramScheduleItemsWithDurations(id), cancellationToken);
         return new OkObjectResult(items);
     }
 

ErsatzTV/Controllers/Api/WatermarkController.cs

@@ -0,0 +1,19 @@
+using ErsatzTV.Application.Watermarks;
+using ErsatzTV.Core.Api.Watermarks;
+using MediatR;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ErsatzTV.Controllers.Api;
+
+[ApiController]
+public class WatermarkController(IMediator mediator) : ControllerBase
+{
+    [HttpGet("/api/watermarks", Name = "GetWatermarks")]
+    [Tags("Watermarks")]
+    [EndpointSummary("Get all watermarks")]
+    [EndpointGroupName("general")]
+    [ProducesResponseType(typeof(List<WatermarkResponseModel>), StatusCodes.Status200OK)]
+    public async Task<List<WatermarkResponseModel>> GetAll(CancellationToken cancellationToken) =>
+        await mediator.Send(new GetAllWatermarksForApi(), cancellationToken);
+}